From d742e99a8c8696efa47bedd17499a4e504e160fc Mon Sep 17 00:00:00 2001
From: "Stephen F. Booth" <me@sbooth.org>
Date: Sun, 10 Aug 2025 11:09:16 -0500
Subject: [PATCH 1/2] Convert to throwing functions

---
 .../JulianDayNumber/ArmenianCalendar.swift    |   8 +-
 .../AstronomicalCalendar.swift                |  12 +-
 Sources/JulianDayNumber/BahaiCalendar.swift   |   8 +-
 .../JulianDayNumber/Calendar+JulianDate.swift |  18 +-
 Sources/JulianDayNumber/Calendar.swift        |  24 +-
 Sources/JulianDayNumber/CopticCalendar.swift  |   8 +-
 .../JulianDayNumber/EgyptianCalendar.swift    |   8 +-
 .../JulianDayNumber/EthiopianCalendar.swift   |   8 +-
 .../FrenchRepublicanCalendar.swift            |   8 +-
 .../JulianDayNumber/GregorianCalendar.swift   |   8 +-
 Sources/JulianDayNumber/HebrewCalendar.swift  |   4 +-
 Sources/JulianDayNumber/ISOCalendar.swift     |  34 +-
 Sources/JulianDayNumber/IslamicCalendar.swift |   8 +-
 Sources/JulianDayNumber/JDNConverter.swift    |   8 +-
 .../JDNGregorianConverter.swift               |   8 +-
 .../JulianDayNumber/JDNSakaConverter.swift    |   8 +-
 Sources/JulianDayNumber/JulianCalendar.swift  |   8 +-
 .../JulianDayNumberConverting.swift           |  14 +-
 .../JulianDayNumber/KhwarizmianCalendar.swift |   8 +-
 .../JulianDayNumber/MacedonianCalendar.swift  |   8 +-
 Sources/JulianDayNumber/MayaCalendar.swift    |  16 +-
 Sources/JulianDayNumber/PersianCalendar.swift |   8 +-
 Sources/JulianDayNumber/SakaCalendar.swift    |   8 +-
 Sources/JulianDayNumber/SyrianCalendar.swift  |   8 +-
 .../ArmenianCalendarTests.swift               |  54 +--
 .../AstronomicalCalendarTests.swift           | 220 ++++++-------
 .../BahaiCalendarTests.swift                  |  52 +--
 .../CongruenceTests.swift                     |  44 +--
 .../CopticCalendarTests.swift                 |  54 +--
 .../EgyptianCalendarTests.swift               |  46 +--
 .../EthiopianCalendarTests.swift              |  56 ++--
 .../FrenchRepublicanCalendarTests.swift       |  52 +--
 .../GregorianCalendarTests.swift              | 120 +++----
 .../HebrewCalendarTests.swift                 |  78 ++---
 .../ISOCalendarTests.swift                    |  48 +--
 .../IslamicCalendarTests.swift                |  54 +--
 .../JDNRoundTripTests.swift                   |  78 ++---
 .../JulianCalendarTests.swift                 | 310 +++++++++---------
 .../KhwarizmianCalendarTests.swift            |  50 +--
 .../MacedonianCalendarTests.swift             |  54 +--
 .../MayaCalendarTests.swift                   |  80 ++---
 .../PersianCalendarTests.swift                |  50 +--
 .../SakaCalendarTests.swift                   |  52 +--
 .../SyrianCalendarTests.swift                 |  54 +--
 44 files changed, 954 insertions(+), 910 deletions(-)

diff --git a/Sources/JulianDayNumber/ArmenianCalendar.swift b/Sources/JulianDayNumber/ArmenianCalendar.swift
index 936b35b..35f8fd0 100644
--- a/Sources/JulianDayNumber/ArmenianCalendar.swift
+++ b/Sources/JulianDayNumber/ArmenianCalendar.swift
@@ -36,12 +36,12 @@ public struct ArmenianCalendar: Calendar {
 	/// The converter for the Armenian calendar.
 	static let converter = JDNConverter(y: 5268, j: 317, m: 0, n: 13, r: 1, p: 365, q: 0, v: 0, u: 1, s: 30, t: 0, w: 0)
 
-	public static func julianDayNumberFromDate(_ date: DateType) -> JulianDayNumber {
-		converter.julianDayNumberFromDate(date)
+	public static func julianDayNumberFromDate(_ date: DateType) throws -> JulianDayNumber {
+		try converter.julianDayNumberFromDate(date)
 	}
 
-	public static func dateFromJulianDayNumber(_ J: JulianDayNumber) -> DateType {
-		converter.dateFromJulianDayNumber(J)
+	public static func dateFromJulianDayNumber(_ J: JulianDayNumber) throws -> DateType {
+		try converter.dateFromJulianDayNumber(J)
 	}
 
 	/// The number of months in one year.b
diff --git a/Sources/JulianDayNumber/AstronomicalCalendar.swift b/Sources/JulianDayNumber/AstronomicalCalendar.swift
index d428e0c..2c4aeb5 100644
--- a/Sources/JulianDayNumber/AstronomicalCalendar.swift
+++ b/Sources/JulianDayNumber/AstronomicalCalendar.swift
@@ -26,8 +26,10 @@ public struct AstronomicalCalendar: Calendar {
 	/// - parameter date: A date to convert.
 	///
 	/// - returns: The Julian day number corresponding to the specified date.
-	public static func julianDayNumberFromDate(_ date: DateType) -> JulianDayNumber {
-		date < firstGregorianCalendarDate ? JulianCalendar.julianDayNumberFromDate(date) : GregorianCalendar.julianDayNumberFromDate(date)
+	///
+	/// - throws: An error if the date could not be converted to a Julian Day Number.
+	public static func julianDayNumberFromDate(_ date: DateType) throws -> JulianDayNumber {
+		date < firstGregorianCalendarDate ? try JulianCalendar.julianDayNumberFromDate(date) : try GregorianCalendar.julianDayNumberFromDate(date)
 	}
 
 	/// Converts a Julian day number to a date in the astronomical calendar.
@@ -37,8 +39,10 @@ public struct AstronomicalCalendar: Calendar {
 	/// - parameter J: A Julian day number.
 	///
 	/// - returns: The date corresponding to the specified Julian day number.
-	public static func dateFromJulianDayNumber(_ J: JulianDayNumber) -> DateType {
-		J < GregorianCalendar.effectiveJulianDayNumber ? JulianCalendar.dateFromJulianDayNumber(J): GregorianCalendar.dateFromJulianDayNumber(J)
+	///
+	/// - throws: An error if the Julian Day Number could not be converted to a date.
+	public static func dateFromJulianDayNumber(_ J: JulianDayNumber) throws -> DateType {
+		J < GregorianCalendar.effectiveJulianDayNumber ? try JulianCalendar.dateFromJulianDayNumber(J): try GregorianCalendar.dateFromJulianDayNumber(J)
 	}
 
 	/// The number of months in one year.
diff --git a/Sources/JulianDayNumber/BahaiCalendar.swift b/Sources/JulianDayNumber/BahaiCalendar.swift
index b3f8a8e..937f5e5 100644
--- a/Sources/JulianDayNumber/BahaiCalendar.swift
+++ b/Sources/JulianDayNumber/BahaiCalendar.swift
@@ -43,12 +43,12 @@ public struct BahaiCalendar: Calendar {
 	/// The converter for the Baháʼí calendar.
 	static let converter = JDNGregorianConverter(y: 6560, j: 1412, m: 19, n: 20, r: 4, p: 1461, q: 0, v: 3, u: 1, s: 19, t: 0, w: 0, A: 184, B: 274273, C: -50)
 
-	public static func julianDayNumberFromDate(_ date: DateType) -> JulianDayNumber {
-		converter.julianDayNumberFromDate(date)
+	public static func julianDayNumberFromDate(_ date: DateType) throws -> JulianDayNumber {
+		try converter.julianDayNumberFromDate(date)
 	}
 
-	public static func dateFromJulianDayNumber(_ J: JulianDayNumber) -> DateType {
-		converter.dateFromJulianDayNumber(J)
+	public static func dateFromJulianDayNumber(_ J: JulianDayNumber) throws -> DateType {
+		try converter.dateFromJulianDayNumber(J)
 	}
 
 	/// The number of months in one year.
diff --git a/Sources/JulianDayNumber/Calendar+JulianDate.swift b/Sources/JulianDayNumber/Calendar+JulianDate.swift
index 2b68d04..24490ce 100644
--- a/Sources/JulianDayNumber/Calendar+JulianDate.swift
+++ b/Sources/JulianDayNumber/Calendar+JulianDate.swift
@@ -39,8 +39,10 @@ extension Calendar {
 	/// - parameter s: A second number on the half-open interval `[0, 60)`.
 	///
 	/// - returns: The Julian date corresponding to the specified year, month, day, hour, minute, and second.
-	public static func julianDateFrom(year Y: Year, month M: Month, day D: Day, hour h: Hour = 0, minute m: Minute = 0, second s: Second = 0) -> JulianDate {
-		julianDateFrom(year: Y, month: M, day: Double(D) + fractionalDayFrom(hour: h, minute: m, second: s))
+	///
+	/// - throws: An error if the year, month, day, hour, minute, and second could not be converted to a Julian date.
+	public static func julianDateFrom(year Y: Year, month M: Month, day D: Day, hour h: Hour = 0, minute m: Minute = 0, second s: Second = 0) throws -> JulianDate {
+		try julianDateFrom(year: Y, month: M, day: Double(D) + fractionalDayFrom(hour: h, minute: m, second: s))
 	}
 
 	/// Converts the specified year, month, and decimal fractional day to a Julian date and returns the result.
@@ -52,9 +54,11 @@ extension Calendar {
 	/// - parameter D: A decimal fractional day number.
 	///
 	/// - returns: The Julian date corresponding to the specified year, month, and decimal day.
-	public static func julianDateFrom(year Y: Year, month M: Month, day D: FractionalDay) -> JulianDate {
+	///
+	/// - throws: An error if the year, month, and decimal fractional day could not be converted to a Julian date.
+	public static func julianDateFrom(year Y: Year, month M: Month, day D: FractionalDay) throws -> JulianDate {
 		let (day, dayFraction) = modf(D)
-		return Double(julianDayNumberFrom(year: Y, month: M, day: Int(day))) - 0.5 + dayFraction
+		return Double(try julianDayNumberFrom(year: Y, month: M, day: Int(day))) - 0.5 + dayFraction
 	}
 
 	/// Converts the specified Julian date to a year, month, day, hour, minute, and second and returns the result.
@@ -62,10 +66,12 @@ extension Calendar {
 	/// - parameter julianDate: A Julian date.
 	///
 	/// - returns: The year, month, day, hour, minute, and second corresponding to the specified Julian date.
-	public static func dateAndTimeFromJulianDate(_ julianDate: JulianDate) -> (year: Year, month: Month, day: Day, hour: Hour, minute: Minute, second: Second) {
+	///
+	/// - throws: An error if the Julian date could not be converted to a year, month, and decimal fractional day.
+	public static func dateAndTimeFromJulianDate(_ julianDate: JulianDate) throws -> (year: Year, month: Month, day: Day, hour: Hour, minute: Minute, second: Second) {
 		let julianDatePlus12Hours = julianDate + 0.5
 		let J = JulianDayNumber(julianDatePlus12Hours.rounded(.down))
-		let (Y, M, D) = dateFromJulianDayNumber(J)
+		let (Y, M, D) = try dateFromJulianDayNumber(J)
 		var (_, dayFraction) = modf(julianDatePlus12Hours)
 		if dayFraction < 0 {
 			dayFraction += 1
diff --git a/Sources/JulianDayNumber/Calendar.swift b/Sources/JulianDayNumber/Calendar.swift
index 79fa6cc..ab4976c 100644
--- a/Sources/JulianDayNumber/Calendar.swift
+++ b/Sources/JulianDayNumber/Calendar.swift
@@ -72,8 +72,10 @@ extension Calendar {
 	/// - parameter D: A day number.
 	///
 	/// - returns: The Julian day number corresponding to the specified year, month, and day.
-	public static func julianDayNumberFrom(year Y: Year, month M: Month, day D: Day) -> JulianDayNumber {
-		julianDayNumberFromDate((Y, M, D))
+	///
+	/// - throws: An error if the year, month, and day could not be converted to a Julian Day Number.
+	public static func julianDayNumberFrom(year Y: Year, month M: Month, day D: Day) throws -> JulianDayNumber {
+		try julianDayNumberFromDate((Y, M, D))
 	}
 
 	/// An ordinal day.
@@ -86,8 +88,10 @@ extension Calendar {
 	/// - parameter D: A day number.
 	///
 	/// - returns: The ordinal day corresponding to the specified year, month, and day.
-	public static func ordinalDayFrom(year Y: Year, month M: Month, day D: Day) -> OrdinalDay {
-		OrdinalDay(julianDayNumberFrom(year: Y, month: M, day: D) - julianDayNumberFrom(year: Y, month: 1, day: 1) + 1)
+	///
+	/// - throws: An error if the year, month, and day could not be converted to an ordinal day.
+	public static func ordinalDayFrom(year Y: Year, month M: Month, day D: Day) throws -> OrdinalDay {
+		try OrdinalDay(julianDayNumberFrom(year: Y, month: M, day: D) - julianDayNumberFrom(year: Y, month: 1, day: 1) + 1)
 	}
 
 	/// Converts a year and ordinal day to a year, month, and day and returns the result.
@@ -96,8 +100,10 @@ extension Calendar {
 	/// - parameter N: An ordinal day number.
 	///
 	/// - returns: The year, month, and day corresponding to the specified year and ordinal day.
-	public static func dateFrom(year Y: Year, ordinalDay N: OrdinalDay) -> DateType {
-		dateFromJulianDayNumber(julianDayNumberFrom(year: Y, month: 1, day: 1) + JulianDayNumber(N) - 1)
+	///
+	/// - throws: An error if the year and ordinal day could not be converted to a date.
+	public static func dateFrom(year Y: Year, ordinalDay N: OrdinalDay) throws -> DateType {
+		try dateFromJulianDayNumber(julianDayNumberFrom(year: Y, month: 1, day: 1) + JulianDayNumber(N) - 1)
 	}
 }
 
@@ -110,7 +116,9 @@ extension Calendar {
 	/// - parameter calendar: The calendar to use for conversion.
 	///
 	/// - returns: The specified date converted to a date in the specified calendar.
-	public static func convert<C>(year Y: Year, month M: Month, day D: Day, to calendar: C.Type) -> C.DateType where C: CalendarProtocol {
-		convertDate((Y, M, D), using: calendar)
+	///
+	/// - throws: An error if the year, month, and day could not be converted to a date in the specified calendar.
+	public static func convert<C>(year Y: Year, month M: Month, day D: Day, to calendar: C.Type) throws -> C.DateType where C: CalendarProtocol {
+		try convertDate((Y, M, D), using: calendar)
 	}
 }
diff --git a/Sources/JulianDayNumber/CopticCalendar.swift b/Sources/JulianDayNumber/CopticCalendar.swift
index a2ae06b..8b42cb9 100644
--- a/Sources/JulianDayNumber/CopticCalendar.swift
+++ b/Sources/JulianDayNumber/CopticCalendar.swift
@@ -36,12 +36,12 @@ public struct CopticCalendar: Calendar {
 	/// The converter for the Coptic calendar.
 	static let converter = JDNConverter(y: 4996, j: 124, m: 0, n: 13, r: 4, p: 1461, q: 0, v: 3, u: 1, s: 30, t: 0, w: 0)
 
-	public static func julianDayNumberFromDate(_ date: DateType) -> JulianDayNumber {
-		converter.julianDayNumberFromDate(date)
+	public static func julianDayNumberFromDate(_ date: DateType) throws -> JulianDayNumber {
+		try converter.julianDayNumberFromDate(date)
 	}
 
-	public static func dateFromJulianDayNumber(_ J: JulianDayNumber) -> DateType {
-		converter.dateFromJulianDayNumber(J)
+	public static func dateFromJulianDayNumber(_ J: JulianDayNumber) throws -> DateType {
+		try converter.dateFromJulianDayNumber(J)
 	}
 
 	/// The number of months in one year.
diff --git a/Sources/JulianDayNumber/EgyptianCalendar.swift b/Sources/JulianDayNumber/EgyptianCalendar.swift
index 9711e97..dd9eff6 100644
--- a/Sources/JulianDayNumber/EgyptianCalendar.swift
+++ b/Sources/JulianDayNumber/EgyptianCalendar.swift
@@ -36,12 +36,12 @@ public struct EgyptianCalendar: Calendar {
 	/// The converter for the Egyptian calendar.
 	static let converter = JDNConverter(y: 3968, j: 47, m: 0, n: 13, r: 1, p: 365, q: 0, v: 0, u: 1, s: 30, t: 0, w: 0)
 
-	public static func julianDayNumberFromDate(_ date: DateType) -> JulianDayNumber {
-		converter.julianDayNumberFromDate(date)
+	public static func julianDayNumberFromDate(_ date: DateType) throws -> JulianDayNumber {
+		try converter.julianDayNumberFromDate(date)
 	}
 
-	public static func dateFromJulianDayNumber(_ J: JulianDayNumber) -> DateType {
-		converter.dateFromJulianDayNumber(J)
+	public static func dateFromJulianDayNumber(_ J: JulianDayNumber) throws -> DateType {
+		try converter.dateFromJulianDayNumber(J)
 	}
 
 	/// The number of months in one year.
diff --git a/Sources/JulianDayNumber/EthiopianCalendar.swift b/Sources/JulianDayNumber/EthiopianCalendar.swift
index ca77ef2..47c4c77 100644
--- a/Sources/JulianDayNumber/EthiopianCalendar.swift
+++ b/Sources/JulianDayNumber/EthiopianCalendar.swift
@@ -36,12 +36,12 @@ public struct EthiopianCalendar: Calendar {
 	/// The converter for the Ethiopian calendar.
 	static let converter = JDNConverter(y: 4720, j: 124, m: 0, n: 13, r: 4, p: 1461, q: 0, v: 3, u: 1, s: 30, t: 0, w: 0)
 
-	public static func julianDayNumberFromDate(_ date: DateType) -> JulianDayNumber {
-		converter.julianDayNumberFromDate(date)
+	public static func julianDayNumberFromDate(_ date: DateType) throws -> JulianDayNumber {
+		try converter.julianDayNumberFromDate(date)
 	}
 
-	public static func dateFromJulianDayNumber(_ J: JulianDayNumber) -> DateType {
-		converter.dateFromJulianDayNumber(J)
+	public static func dateFromJulianDayNumber(_ J: JulianDayNumber) throws -> DateType {
+		try converter.dateFromJulianDayNumber(J)
 	}
 
 	/// The number of months in one year.
diff --git a/Sources/JulianDayNumber/FrenchRepublicanCalendar.swift b/Sources/JulianDayNumber/FrenchRepublicanCalendar.swift
index 9f5ecc3..990bb3e 100644
--- a/Sources/JulianDayNumber/FrenchRepublicanCalendar.swift
+++ b/Sources/JulianDayNumber/FrenchRepublicanCalendar.swift
@@ -41,12 +41,12 @@ public struct FrenchRepublicanCalendar: Calendar {
 	/// The converter for the French Republican calendar.
 	static let converter = JDNGregorianConverter(y: 6504, j: 111, m: 0, n: 13, r: 4, p: 1461, q: 0, v: 3, u: 1, s: 30, t: 0, w: 0, A: 396, B: 578797, C: -51)
 
-	public static func julianDayNumberFromDate(_ date: DateType) -> JulianDayNumber {
-		converter.julianDayNumberFromDate(date)
+	public static func julianDayNumberFromDate(_ date: DateType) throws -> JulianDayNumber {
+		try converter.julianDayNumberFromDate(date)
 	}
 
-	public static func dateFromJulianDayNumber(_ J: JulianDayNumber) -> DateType {
-		converter.dateFromJulianDayNumber(J)
+	public static func dateFromJulianDayNumber(_ J: JulianDayNumber) throws -> DateType {
+		try converter.dateFromJulianDayNumber(J)
 	}
 
 	/// The number of months in one year.
diff --git a/Sources/JulianDayNumber/GregorianCalendar.swift b/Sources/JulianDayNumber/GregorianCalendar.swift
index 59f9cf3..38a0a2a 100644
--- a/Sources/JulianDayNumber/GregorianCalendar.swift
+++ b/Sources/JulianDayNumber/GregorianCalendar.swift
@@ -42,12 +42,12 @@ public struct GregorianCalendar: Calendar {
 	/// The converter for the Gregorian calendar.
 	static let converter = JDNGregorianConverter(y: 4716, j: 1401, m: 2, n: 12, r: 4, p: 1461, q: 0, v: 3, u: 5, s: 153, t: 2, w: 2, A: 184, B: 274277, C: -38)
 
-	public static func julianDayNumberFromDate(_ date: DateType) -> JulianDayNumber {
-		converter.julianDayNumberFromDate(date)
+	public static func julianDayNumberFromDate(_ date: DateType) throws -> JulianDayNumber {
+		try converter.julianDayNumberFromDate(date)
 	}
 
-	public static func dateFromJulianDayNumber(_ J: JulianDayNumber) -> DateType {
-		converter.dateFromJulianDayNumber(J)
+	public static func dateFromJulianDayNumber(_ J: JulianDayNumber) throws -> DateType {
+		try converter.dateFromJulianDayNumber(J)
 	}
 
 	/// The Julian day number when the Gregorian calendar took effect.
diff --git a/Sources/JulianDayNumber/HebrewCalendar.swift b/Sources/JulianDayNumber/HebrewCalendar.swift
index 5e7ea54..3e69c75 100644
--- a/Sources/JulianDayNumber/HebrewCalendar.swift
+++ b/Sources/JulianDayNumber/HebrewCalendar.swift
@@ -63,7 +63,7 @@ public struct HebrewCalendar: Calendar {
 	/// An intercalating cycle in the Hebrew calendar consists of 689,472 years, 8,527,680 months, 35,975,351 weeks, or 251,827,457 days.
 	static let intercalatingCycle = (years: 689472, days: 251827457)
 
-	public static func julianDayNumberFromDate(_ date: DateType) -> JulianDayNumber {
+	public static func julianDayNumberFromDate(_ date: DateType) throws -> JulianDayNumber {
 		var Y = date.year
 		var ΔcalendarCycles = 0
 
@@ -84,7 +84,7 @@ public struct HebrewCalendar: Calendar {
 		return J
 	}
 
-	public static func dateFromJulianDayNumber(_ J: JulianDayNumber) -> DateType {
+	public static func dateFromJulianDayNumber(_ J: JulianDayNumber) throws -> DateType {
 		var J = J
 		var ΔcalendarCycles = 0
 
diff --git a/Sources/JulianDayNumber/ISOCalendar.swift b/Sources/JulianDayNumber/ISOCalendar.swift
index 7e489b7..409a872 100644
--- a/Sources/JulianDayNumber/ISOCalendar.swift
+++ b/Sources/JulianDayNumber/ISOCalendar.swift
@@ -25,13 +25,13 @@ public struct ISOCalendar: CalendarProtocol {
 	/// This JDN corresponds to January 3, 1 CE in the Julian calendar.
 	public static let epoch = GregorianCalendar.epoch
 
-	public static func julianDayNumberFromDate(_ date: DateType) -> JulianDayNumber {
-		GregorianCalendar.julianDayNumberFromDate(dateFromISO(year: date.year, week: date.week, weekday: date.weekday))
+	public static func julianDayNumberFromDate(_ date: DateType) throws -> JulianDayNumber {
+		try GregorianCalendar.julianDayNumberFromDate(dateFromISO(year: date.year, week: date.week, weekday: date.weekday))
 	}
 
-	public static func dateFromJulianDayNumber(_ J: JulianDayNumber) -> DateType {
-		let (Y, M, D) = GregorianCalendar.dateFromJulianDayNumber(J)
-		return isoDateFrom(year: Y, month: M, day: D)
+	public static func dateFromJulianDayNumber(_ J: JulianDayNumber) throws -> DateType {
+		let (Y, M, D) = try GregorianCalendar.dateFromJulianDayNumber(J)
+		return try isoDateFrom(year: Y, month: M, day: D)
 	}
 
 	/// Returns the number of ISO full weeks in a year.
@@ -55,13 +55,13 @@ public struct ISOCalendar: CalendarProtocol {
 		return 52
 	}
 
-	/// Returns the ISO weekday for the specified year, month, and day.
+	/// Returns the ISO weekday for the specified Gregorian year, month, and day.
 	///
 	/// - parameter Y: A Gregorian year number.
 	/// - parameter M: A month number.
 	/// - parameter D: A day number.
 	///
-	/// - returns: The ISO weekday from `1` (Monday) to `7` (Sunday) corresponding to the specified year, month, and day.
+	/// - returns: The ISO weekday from `1` (Monday) to `7` (Sunday) corresponding to the specified Gregorian year, month, and day.
 	static func isoWeekdayFrom(year Y: Int, month M: Int, day D: Int) -> WeekdayNumber {
 		let weekday = GregorianCalendar.dayOfWeekFrom(year: Y, month: M, day: D) - 1
 		return weekday < 1 ? weekday + 7 : weekday
@@ -72,15 +72,17 @@ public struct ISOCalendar: CalendarProtocol {
 		date.weekday > 0 && date.weekday <= 7 && date.week > 0 && date.week <= isoWeeksInYear(date.year)
 	}
 
-	/// Returns the ISO week date for the specified year, month, and day.
+	/// Returns the ISO week date for the specified Gregorian year, month, and day.
 	///
 	/// - parameter Y: A Gregorian year number.
 	/// - parameter M: A month number.
 	/// - parameter D: A day number.
 	///
-	/// - returns: The ISO week date corresponding to the specified year, month, and day.
-	public static func isoDateFrom(year Y: Int, month M: Int, day D: Int) -> (year: Year, week: WeekNumber, weekday: WeekdayNumber) {
-		let N = GregorianCalendar.ordinalDayFrom(year: Y, month: M, day: D)
+	/// - returns: The ISO week date corresponding to the specified Gregorian year, month, and day.
+	///
+	/// - throws: An error if the year, month, and day could not be converted to an ISO week date.
+	public static func isoDateFrom(year Y: Int, month M: Int, day D: Int) throws -> (year: Year, week: WeekNumber, weekday: WeekdayNumber) {
+		let N = try GregorianCalendar.ordinalDayFrom(year: Y, month: M, day: D)
 		let weekday = isoWeekdayFrom(year: Y, month: M, day: D)
 		let w = (10 + N - weekday) / 7
 		if w == 0 {
@@ -91,15 +93,17 @@ public struct ISOCalendar: CalendarProtocol {
 		return (Y, w, weekday)
 	}
 
-	/// Returns the date for the specified year, ISO week number, and ISO weekday number.
+	/// Returns the Gregorian date for the specified year, ISO week number, and ISO weekday number.
 	///
 	/// - parameter Y: A Gregorian year number.
 	/// - parameter week: An ISO week number.
 	/// - parameter weekday: An ISO weekday number.
 	///
-	/// - returns: The date corresponding to the specified Gregorian year, ISO week number, and ISO weekday number.
-	public static func dateFromISO(year Y: Year, week: WeekNumber, weekday: WeekdayNumber) -> (year: Int, month: Int, day: Int) {
+	/// - returns: The Gregorian date corresponding to the specified Gregorian year, ISO week number, and ISO weekday number.
+	///
+	/// - throws: An error if the year, ISO week number, and ISO weekday number could not be converted to a date.
+	public static func dateFromISO(year Y: Year, week: WeekNumber, weekday: WeekdayNumber) throws -> GregorianCalendar.DateType {
 		let N = week * 7 + weekday - isoWeekdayFrom(year: Y, month: 1, day: 4) - 3
-		return GregorianCalendar.dateFrom(year: Y, ordinalDay: N)
+		return try GregorianCalendar.dateFrom(year: Y, ordinalDay: N)
 	}
 }
diff --git a/Sources/JulianDayNumber/IslamicCalendar.swift b/Sources/JulianDayNumber/IslamicCalendar.swift
index 67e3912..2980f48 100644
--- a/Sources/JulianDayNumber/IslamicCalendar.swift
+++ b/Sources/JulianDayNumber/IslamicCalendar.swift
@@ -35,12 +35,12 @@ public struct IslamicCalendar: Calendar {
 	/// The converter for the Islamic calendar.
 	static let converter = JDNConverter(y: 5519, j: 7664, m: 0, n: 12, r: 30, p: 10631, q: 14, v: 15, u: 100, s: 2951, t: 51, w: 10)
 
-	public static func julianDayNumberFromDate(_ date: DateType) -> JulianDayNumber {
-		converter.julianDayNumberFromDate(date)
+	public static func julianDayNumberFromDate(_ date: DateType) throws -> JulianDayNumber {
+		try converter.julianDayNumberFromDate(date)
 	}
 
-	public static func dateFromJulianDayNumber(_ J: JulianDayNumber) -> DateType {
-		converter.dateFromJulianDayNumber(J)
+	public static func dateFromJulianDayNumber(_ J: JulianDayNumber) throws -> DateType {
+		try converter.dateFromJulianDayNumber(J)
 	}
 
 	/// The number of months in one year.
diff --git a/Sources/JulianDayNumber/JDNConverter.swift b/Sources/JulianDayNumber/JDNConverter.swift
index d164ff3..97a1f70 100644
--- a/Sources/JulianDayNumber/JDNConverter.swift
+++ b/Sources/JulianDayNumber/JDNConverter.swift
@@ -46,7 +46,9 @@ struct JDNConverter {
 	/// - parameter date: A date to convert.
 	///
 	/// - returns: The Julian day number corresponding to the specified date.
-	func julianDayNumberFromDate(_ date: Calendar.YearMonthDay) -> JulianDayNumber {
+	///
+	/// - throws: An error if the date could not be converted to a Julian Day Number.
+	func julianDayNumberFromDate(_ date: Calendar.YearMonthDay) throws -> JulianDayNumber {
 		// Arithmetic upper limit
 		// `Y` values larger than this cause overflow when `e` is computed
 		let maxY = (.max / p) - y + (n - (date.month - m)) / n
@@ -92,7 +94,9 @@ struct JDNConverter {
 	/// - parameter J: A Julian day number.
 	///
 	/// - returns: The date corresponding to the specified Julian day number.
-	func dateFromJulianDayNumber(_ J: JulianDayNumber) -> Calendar.YearMonthDay {
+	///
+	/// - throws: An error if the Julian Day Number could not be converted to a date.
+	func dateFromJulianDayNumber(_ J: JulianDayNumber) throws -> Calendar.YearMonthDay {
 		// Arithmetic upper limit
 		// `J` values larger than this cause overflow when `e` is computed
 		let maxJ = (.max - v) / r - j
diff --git a/Sources/JulianDayNumber/JDNGregorianConverter.swift b/Sources/JulianDayNumber/JDNGregorianConverter.swift
index b3a0cda..57accf3 100644
--- a/Sources/JulianDayNumber/JDNGregorianConverter.swift
+++ b/Sources/JulianDayNumber/JDNGregorianConverter.swift
@@ -43,7 +43,9 @@ struct JDNGregorianConverter {
 	/// - parameter date: A date to convert.
 	///
 	/// - returns: The Julian day number corresponding to the specified date.
-	func julianDayNumberFromDate(_ date: Calendar.YearMonthDay) -> JulianDayNumber {
+	///
+	/// - throws: An error if the date could not be converted to a Julian Day Number.
+	func julianDayNumberFromDate(_ date: Calendar.YearMonthDay) throws -> JulianDayNumber {
 		// Arithmetic upper limit
 		// `Y` values larger than this cause overflow when `e` is computed
 		let maxY = (.max / p) - y + (n - (date.month - m)) / n
@@ -92,7 +94,9 @@ struct JDNGregorianConverter {
 	/// - parameter J: A Julian day number.
 	///
 	/// - returns: The date corresponding to the specified Julian day number.
-	func dateFromJulianDayNumber(_ J: JulianDayNumber) -> Calendar.YearMonthDay {
+	///
+	/// - throws: An error if the Julian Day Number could not be converted to a date.
+	func dateFromJulianDayNumber(_ J: JulianDayNumber) throws -> Calendar.YearMonthDay {
 		// Approximate arithmetic upper limit (the true upper limit is very difficult to calculate)
 		// Most `J` values larger than this cause overflow when `e` is computed
 		let maxJ = .max / 5
diff --git a/Sources/JulianDayNumber/JDNSakaConverter.swift b/Sources/JulianDayNumber/JDNSakaConverter.swift
index 9238a05..ad6bb3a 100644
--- a/Sources/JulianDayNumber/JDNSakaConverter.swift
+++ b/Sources/JulianDayNumber/JDNSakaConverter.swift
@@ -40,7 +40,9 @@ struct JDNSakaConverter {
 	/// - parameter date: A date to convert.
 	///
 	/// - returns: The Julian day number corresponding to the specified date.
-	func julianDayNumberFromDate(_ date: Calendar.YearMonthDay) -> JulianDayNumber {
+	///
+	/// - throws: An error if the date could not be converted to a Julian Day Number.
+	func julianDayNumberFromDate(_ date: Calendar.YearMonthDay) throws -> JulianDayNumber {
 		// Arithmetic upper limit
 		// `Y` values larger than this cause overflow when `e` is computed
 		let maxY = (.max / p) - y + (n - (date.month - m)) / n
@@ -90,7 +92,9 @@ struct JDNSakaConverter {
 	/// - parameter J: A Julian day number.
 	///
 	/// - returns: The date corresponding to the specified Julian day number.
-	func dateFromJulianDayNumber(_ J: JulianDayNumber) -> Calendar.YearMonthDay {
+	///
+	/// - throws: An error if the Julian Day Number could not be converted to a date.
+	func dateFromJulianDayNumber(_ J: JulianDayNumber) throws -> Calendar.YearMonthDay {
 		// Approximate arithmetic upper limit (the true upper limit is very difficult to calculate)
 		// Most `J` values larger than this cause overflow when `e` is computed
 		let maxJ = .max / 5
diff --git a/Sources/JulianDayNumber/JulianCalendar.swift b/Sources/JulianDayNumber/JulianCalendar.swift
index c0f331e..5581498 100644
--- a/Sources/JulianDayNumber/JulianCalendar.swift
+++ b/Sources/JulianDayNumber/JulianCalendar.swift
@@ -37,12 +37,12 @@ public struct JulianCalendar: Calendar {
 	/// The converter for the Julian calendar.
 	static let converter = JDNConverter(y: 4716, j: 1401, m: 2, n: 12, r: 4, p: 1461, q: 0, v: 3, u: 5, s: 153, t: 2, w: 2)
 
-	public static func julianDayNumberFromDate(_ date: DateType) -> JulianDayNumber {
-		converter.julianDayNumberFromDate(date)
+	public static func julianDayNumberFromDate(_ date: DateType) throws -> JulianDayNumber {
+		try converter.julianDayNumberFromDate(date)
 	}
 
-	public static func dateFromJulianDayNumber(_ J: JulianDayNumber) -> DateType {
-		converter.dateFromJulianDayNumber(J)
+	public static func dateFromJulianDayNumber(_ J: JulianDayNumber) throws -> DateType {
+		try converter.dateFromJulianDayNumber(J)
 	}
 
 	/// The Julian day number when the Julian calendar took effect.
diff --git a/Sources/JulianDayNumber/JulianDayNumberConverting.swift b/Sources/JulianDayNumber/JulianDayNumberConverting.swift
index 6754f91..6371d97 100644
--- a/Sources/JulianDayNumber/JulianDayNumberConverting.swift
+++ b/Sources/JulianDayNumber/JulianDayNumberConverting.swift
@@ -25,8 +25,10 @@ public protocol JulianDayNumberConverting {
 	///
 	/// - returns: The Julian day number corresponding to the specified date.
 	///
+	/// - throws: An error if the date could not be converted to a Julian Day Number.
+	///
 	/// - seealso: ``dateFromJulianDayNumber(_:)``
-	static func julianDayNumberFromDate(_ date: DateType) -> JulianDayNumber
+	static func julianDayNumberFromDate(_ date: DateType) throws -> JulianDayNumber
 
 	/// Converts a Julian day number to a date and returns the result.
 	///
@@ -34,8 +36,10 @@ public protocol JulianDayNumberConverting {
 	///
 	/// - returns: The date corresponding to the specified Julian day number.
 	///
+	/// - throws: An error if the Julian Day Number could not be converted to a date.
+	///
 	/// - seealso: ``julianDayNumberFromDate(_:)``
-	static func dateFromJulianDayNumber(_ J: JulianDayNumber) -> DateType
+	static func dateFromJulianDayNumber(_ J: JulianDayNumber) throws -> DateType
 }
 
 extension JulianDayNumberConverting {
@@ -45,7 +49,9 @@ extension JulianDayNumberConverting {
 	/// - parameter converter: The converter to use.
 	///
 	/// - returns: The specified date converted to a date using the specified converter.
-	public static func convertDate<C>(_ date: DateType, using converter: C.Type) -> C.DateType where C: JulianDayNumberConverting {
-		C.dateFromJulianDayNumber(Self.julianDayNumberFromDate(date))
+	///
+	/// - throws: An error if the date could not be converted to a date using the specified converter.
+	public static func convertDate<C>(_ date: DateType, using converter: C.Type) throws -> C.DateType where C: JulianDayNumberConverting {
+		try C.dateFromJulianDayNumber(Self.julianDayNumberFromDate(date))
 	}
 }
diff --git a/Sources/JulianDayNumber/KhwarizmianCalendar.swift b/Sources/JulianDayNumber/KhwarizmianCalendar.swift
index 9f5eea2..54bc294 100644
--- a/Sources/JulianDayNumber/KhwarizmianCalendar.swift
+++ b/Sources/JulianDayNumber/KhwarizmianCalendar.swift
@@ -34,12 +34,12 @@ public struct KhwarizmianCalendar: Calendar {
 	/// The converter for the Khwarizmian calendar.
 	static let converter = JDNConverter(y: 5348, j: 317, m: 0, n: 13, r: 1, p: 365, q: 0, v: 0, u: 1, s: 30, t: 0, w: 0)
 
-	public static func julianDayNumberFromDate(_ date: DateType) -> JulianDayNumber {
-		converter.julianDayNumberFromDate(date)
+	public static func julianDayNumberFromDate(_ date: DateType) throws -> JulianDayNumber {
+		try converter.julianDayNumberFromDate(date)
 	}
 
-	public static func dateFromJulianDayNumber(_ J: JulianDayNumber) -> DateType {
-		converter.dateFromJulianDayNumber(J)
+	public static func dateFromJulianDayNumber(_ J: JulianDayNumber) throws -> DateType {
+		try converter.dateFromJulianDayNumber(J)
 	}
 
 	/// The number of months in one year.
diff --git a/Sources/JulianDayNumber/MacedonianCalendar.swift b/Sources/JulianDayNumber/MacedonianCalendar.swift
index 585464c..59a5e5e 100644
--- a/Sources/JulianDayNumber/MacedonianCalendar.swift
+++ b/Sources/JulianDayNumber/MacedonianCalendar.swift
@@ -35,12 +35,12 @@ public struct MacedonianCalendar: Calendar {
 	/// The converter for the Macedonian calendar.
 	static let converter = JDNConverter(y: 4405, j: 1401, m: 6, n: 12, r: 4, p: 1461, q: 0, v: 3, u: 5, s: 153, t: 2, w: 2)
 
-	public static func julianDayNumberFromDate(_ date: DateType) -> JulianDayNumber {
-		converter.julianDayNumberFromDate(date)
+	public static func julianDayNumberFromDate(_ date: DateType) throws -> JulianDayNumber {
+		try converter.julianDayNumberFromDate(date)
 	}
 
-	public static func dateFromJulianDayNumber(_ J: JulianDayNumber) -> DateType {
-		converter.dateFromJulianDayNumber(J)
+	public static func dateFromJulianDayNumber(_ J: JulianDayNumber) throws -> DateType {
+		try converter.dateFromJulianDayNumber(J)
 	}
 
 	/// The number of months in one year.
diff --git a/Sources/JulianDayNumber/MayaCalendar.swift b/Sources/JulianDayNumber/MayaCalendar.swift
index 6532ff2..3625e4d 100644
--- a/Sources/JulianDayNumber/MayaCalendar.swift
+++ b/Sources/JulianDayNumber/MayaCalendar.swift
@@ -110,12 +110,12 @@ public struct MayaCalendar: CalendarProtocol {
 
 	public typealias DateType = LongCount
 
-	public static func julianDayNumberFromDate(_ date: DateType) -> JulianDayNumber {
-		julianDayNumberFromLongCount(baktun: date.baktun, katun: date.katun, tun: date.tun, uinal: date.uinal, kin: date.kin)
+	public static func julianDayNumberFromDate(_ date: DateType) throws -> JulianDayNumber {
+		try julianDayNumberFromLongCount(baktun: date.baktun, katun: date.katun, tun: date.tun, uinal: date.uinal, kin: date.kin)
 	}
 
-	public static func dateFromJulianDayNumber(_ J: JulianDayNumber) -> DateType {
-		longCountFromJulianDayNumber(J)
+	public static func dateFromJulianDayNumber(_ J: JulianDayNumber) throws -> DateType {
+		try longCountFromJulianDayNumber(J)
 	}
 
 	public static func isValidDate(_ date: DateType) -> Bool {
@@ -143,7 +143,9 @@ extension MayaCalendar {
 	/// - parameter J: A Julian day number.
 	///
 	/// - returns: The long count corresponding to the specified Julian day number.
-	public static func longCountFromJulianDayNumber(_ J: JulianDayNumber) -> LongCount {
+	///
+	/// - throws: An error if the Julian Day Number could not be converted to a long count.
+	public static func longCountFromJulianDayNumber(_ J: JulianDayNumber) throws -> LongCount {
 		var baktun, katun, tun, uinal, kin: Int
 
 		// Compute the long count cycle values
@@ -191,7 +193,9 @@ extension MayaCalendar {
 	/// - parameter kin: A kin number.
 	///
 	/// - returns: The Julian day number corresponding to the specified long count.
-	public static func julianDayNumberFromLongCount(baktun: Baktun, katun: Katun, tun: Tun, uinal: Uinal, kin: Kin) -> JulianDayNumber {
+	///
+	/// - throws: An error if the long count could not be converted to a Julian Day Number.
+	public static func julianDayNumberFromLongCount(baktun: Baktun, katun: Katun, tun: Tun, uinal: Uinal, kin: Kin) throws -> JulianDayNumber {
 		var baktun = baktun + longCountAtTrueEpoch.baktun
 		var katun = katun + longCountAtTrueEpoch.katun
 		var tun = tun + longCountAtTrueEpoch.tun
diff --git a/Sources/JulianDayNumber/PersianCalendar.swift b/Sources/JulianDayNumber/PersianCalendar.swift
index 17ea10d..60ea5ed 100644
--- a/Sources/JulianDayNumber/PersianCalendar.swift
+++ b/Sources/JulianDayNumber/PersianCalendar.swift
@@ -36,12 +36,12 @@ public struct PersianCalendar: Calendar {
 	/// The converter for the Persian calendar.
 	static let converter = JDNConverter(y: 5348, j: 77, m: 9, n: 13, r: 1, p: 365, q: 0, v: 0, u: 1, s: 30, t: 0, w: 0)
 
-	public static func julianDayNumberFromDate(_ date: DateType) -> JulianDayNumber {
-		converter.julianDayNumberFromDate(date)
+	public static func julianDayNumberFromDate(_ date: DateType) throws -> JulianDayNumber {
+		try converter.julianDayNumberFromDate(date)
 	}
 
-	public static func dateFromJulianDayNumber(_ J: JulianDayNumber) -> DateType {
-		converter.dateFromJulianDayNumber(J)
+	public static func dateFromJulianDayNumber(_ J: JulianDayNumber) throws -> DateType {
+		try converter.dateFromJulianDayNumber(J)
 	}
 
 	/// The number of months in one year.
diff --git a/Sources/JulianDayNumber/SakaCalendar.swift b/Sources/JulianDayNumber/SakaCalendar.swift
index 2b940cb..f3f421c 100644
--- a/Sources/JulianDayNumber/SakaCalendar.swift
+++ b/Sources/JulianDayNumber/SakaCalendar.swift
@@ -37,12 +37,12 @@ public struct SakaCalendar: Calendar {
 	/// The converter for the Śaka calendar.
 	static let converter = JDNSakaConverter()
 
-	public static func julianDayNumberFromDate(_ date: DateType) -> JulianDayNumber {
-		converter.julianDayNumberFromDate(date)
+	public static func julianDayNumberFromDate(_ date: DateType) throws -> JulianDayNumber {
+		try converter.julianDayNumberFromDate(date)
 	}
 
-	public static func dateFromJulianDayNumber(_ J: JulianDayNumber) -> DateType {
-		converter.dateFromJulianDayNumber(J)
+	public static func dateFromJulianDayNumber(_ J: JulianDayNumber) throws -> DateType {
+		try converter.dateFromJulianDayNumber(J)
 	}
 
 	/// The Julian day number when the Śaka calendar took effect.
diff --git a/Sources/JulianDayNumber/SyrianCalendar.swift b/Sources/JulianDayNumber/SyrianCalendar.swift
index c082c48..6c4fa52 100644
--- a/Sources/JulianDayNumber/SyrianCalendar.swift
+++ b/Sources/JulianDayNumber/SyrianCalendar.swift
@@ -35,12 +35,12 @@ public struct SyrianCalendar: Calendar {
 	/// The converter for the Syrian calendar.
 	static let converter = JDNConverter(y: 4405, j: 1401, m: 5, n: 12, r: 4, p: 1461, q: 0, v: 3, u: 5, s: 153, t: 2, w: 2)
 
-	public static func julianDayNumberFromDate(_ date: DateType) -> JulianDayNumber {
-		converter.julianDayNumberFromDate(date)
+	public static func julianDayNumberFromDate(_ date: DateType) throws -> JulianDayNumber {
+		try converter.julianDayNumberFromDate(date)
 	}
 
-	public static func dateFromJulianDayNumber(_ J: JulianDayNumber) -> DateType {
-		converter.dateFromJulianDayNumber(J)
+	public static func dateFromJulianDayNumber(_ J: JulianDayNumber) throws -> DateType {
+		try converter.dateFromJulianDayNumber(J)
 	}
 
 	/// The number of months in one year.
diff --git a/Tests/JulianDayNumberTests/ArmenianCalendarTests.swift b/Tests/JulianDayNumberTests/ArmenianCalendarTests.swift
index cc204e1..4fc563a 100644
--- a/Tests/JulianDayNumberTests/ArmenianCalendarTests.swift
+++ b/Tests/JulianDayNumberTests/ArmenianCalendarTests.swift
@@ -8,9 +8,9 @@ import Testing
 @testable import JulianDayNumber
 
 @Suite struct ArmenianCalendarTests {
-	@Test func epoch() {
-		#expect(ArmenianCalendar.julianDayNumberFrom(year: 1, month: 1, day: 1) == ArmenianCalendar.epoch)
-		#expect(ArmenianCalendar.dateFromJulianDayNumber(ArmenianCalendar.epoch) == (1, 1, 1))
+	@Test func epoch() throws {
+		#expect(try ArmenianCalendar.julianDayNumberFrom(year: 1, month: 1, day: 1) == ArmenianCalendar.epoch)
+		#expect(try ArmenianCalendar.dateFromJulianDayNumber(ArmenianCalendar.epoch) == (1, 1, 1))
 	}
 
 	@Test func monthLength() {
@@ -24,36 +24,36 @@ import Testing
 		#expect(ArmenianCalendar.numberOfDaysInYear == 365)
 	}
 
-	@Test func julianDayNumber() {
-		#expect(ArmenianCalendar.julianDayNumberFrom(year: 1, month: 1, day: 1) == 1922868)
-		#expect(ArmenianCalendar.julianDayNumberFrom(year: 1473, month: 4, day: 24) == 2460261)
-		#expect(ArmenianCalendar.dateFromJulianDayNumber(1922868) == (1, 1, 1))
-		#expect(ArmenianCalendar.dateFromJulianDayNumber(2460261) == (1473, 4, 24))
+	@Test func julianDayNumber() throws {
+		#expect(try ArmenianCalendar.julianDayNumberFrom(year: 1, month: 1, day: 1) == 1922868)
+		#expect(try ArmenianCalendar.julianDayNumberFrom(year: 1473, month: 4, day: 24) == 2460261)
+		#expect(try ArmenianCalendar.dateFromJulianDayNumber(1922868) == (1, 1, 1))
+		#expect(try ArmenianCalendar.dateFromJulianDayNumber(2460261) == (1473, 4, 24))
 	}
 
-	@Test func limits() {
-		#expect(ArmenianCalendar.julianDateFrom(year: -999999, month: 1, day: 1) == -363077132.5)
-		#expect(ArmenianCalendar.julianDateFrom(year: -99999, month: 1, day: 1) == -34577132.5)
-		#expect(ArmenianCalendar.julianDateFrom(year: -9999, month: 1, day: 1) == -1727132.5)
-		#expect(ArmenianCalendar.julianDateFrom(year: 9999, month: 13, day: 5) == 5572501.5)
-		#expect(ArmenianCalendar.julianDateFrom(year: 99999, month: 13, day: 5) == 38422501.5)
-		#expect(ArmenianCalendar.julianDateFrom(year: 999999, month: 13, day: 5) == 366922501.5)
-
-		#expect(ArmenianCalendar.dateAndTimeFromJulianDate(-363077132.5) == (-999999, 1, 1, 0, 0, 0))
-		#expect(ArmenianCalendar.dateAndTimeFromJulianDate(-34577132.5) == (-99999, 1, 1, 0, 0, 0))
-		#expect(ArmenianCalendar.dateAndTimeFromJulianDate(-1727132.5) == (-9999, 1, 1, 0, 0, 0))
-		#expect(ArmenianCalendar.dateAndTimeFromJulianDate(5572501.5) == (9999, 13, 5, 0, 0, 0))
-		#expect(ArmenianCalendar.dateAndTimeFromJulianDate(38422501.5) == (99999, 13, 5, 0, 0, 0))
-		#expect(ArmenianCalendar.dateAndTimeFromJulianDate(366922501.5) == (999999, 13, 5, 0, 0, 0))
+	@Test func limits() throws {
+		#expect(try ArmenianCalendar.julianDateFrom(year: -999999, month: 1, day: 1) == -363077132.5)
+		#expect(try ArmenianCalendar.julianDateFrom(year: -99999, month: 1, day: 1) == -34577132.5)
+		#expect(try ArmenianCalendar.julianDateFrom(year: -9999, month: 1, day: 1) == -1727132.5)
+		#expect(try ArmenianCalendar.julianDateFrom(year: 9999, month: 13, day: 5) == 5572501.5)
+		#expect(try ArmenianCalendar.julianDateFrom(year: 99999, month: 13, day: 5) == 38422501.5)
+		#expect(try ArmenianCalendar.julianDateFrom(year: 999999, month: 13, day: 5) == 366922501.5)
+
+		#expect(try ArmenianCalendar.dateAndTimeFromJulianDate(-363077132.5) == (-999999, 1, 1, 0, 0, 0))
+		#expect(try ArmenianCalendar.dateAndTimeFromJulianDate(-34577132.5) == (-99999, 1, 1, 0, 0, 0))
+		#expect(try ArmenianCalendar.dateAndTimeFromJulianDate(-1727132.5) == (-9999, 1, 1, 0, 0, 0))
+		#expect(try ArmenianCalendar.dateAndTimeFromJulianDate(5572501.5) == (9999, 13, 5, 0, 0, 0))
+		#expect(try ArmenianCalendar.dateAndTimeFromJulianDate(38422501.5) == (99999, 13, 5, 0, 0, 0))
+		#expect(try ArmenianCalendar.dateAndTimeFromJulianDate(366922501.5) == (999999, 13, 5, 0, 0, 0))
 	}
 
-	@Test func arithmeticLimits() {
-		let minDate = ArmenianCalendar.dateFromJulianDayNumber(.min + 341)
-		let minJ = ArmenianCalendar.julianDayNumberFromDate(minDate)
+	@Test func arithmeticLimits() throws {
+		let minDate = try ArmenianCalendar.dateFromJulianDayNumber(.min + 341)
+		let minJ = try ArmenianCalendar.julianDayNumberFromDate(minDate)
 		#expect(minJ == .min + 341)
 
-		let maxDate = ArmenianCalendar.dateFromJulianDayNumber(.max)
-		let maxJ = ArmenianCalendar.julianDayNumberFromDate(maxDate)
+		let maxDate = try ArmenianCalendar.dateFromJulianDayNumber(.max)
+		let maxJ = try ArmenianCalendar.julianDayNumberFromDate(maxDate)
 		#expect(maxJ == .max)
 	}
 }
diff --git a/Tests/JulianDayNumberTests/AstronomicalCalendarTests.swift b/Tests/JulianDayNumberTests/AstronomicalCalendarTests.swift
index 8455848..4df6af2 100644
--- a/Tests/JulianDayNumberTests/AstronomicalCalendarTests.swift
+++ b/Tests/JulianDayNumberTests/AstronomicalCalendarTests.swift
@@ -8,9 +8,9 @@ import Testing
 @testable import JulianDayNumber
 
 @Suite struct AstronomicalCalendarTests {
-	@Test func epoch() {
-		#expect(AstronomicalCalendar.julianDayNumberFrom(year: 1, month: 1, day: 1) == AstronomicalCalendar.epoch)
-		#expect(AstronomicalCalendar.dateFromJulianDayNumber(AstronomicalCalendar.epoch) == (1, 1, 1))
+	@Test func epoch() throws {
+		#expect(try AstronomicalCalendar.julianDayNumberFrom(year: 1, month: 1, day: 1) == AstronomicalCalendar.epoch)
+		#expect(try AstronomicalCalendar.dateFromJulianDayNumber(AstronomicalCalendar.epoch) == (1, 1, 1))
 	}
 
 	@Test func dateValidation() {
@@ -20,14 +20,14 @@ import Testing
 		#expect(!AstronomicalCalendar.isValidDate((1582, 10, 10)))
 	}
 
-	@Test func leapYear() {
+	@Test func leapYear() throws {
 		#expect(AstronomicalCalendar.isLeapYear(900))
 		#expect(!AstronomicalCalendar.isLeapYear(1700))
 
 		for y in -1000...2000 {
 			let isLeap = AstronomicalCalendar.isLeapYear(y)
-			let j = AstronomicalCalendar.julianDayNumberFrom(year: y, month: 2, day: isLeap ? 29 : 28)
-			let d = AstronomicalCalendar.dateFromJulianDayNumber(j)
+			let j = try AstronomicalCalendar.julianDayNumberFrom(year: y, month: 2, day: isLeap ? 29 : 28)
+			let d = try AstronomicalCalendar.dateFromJulianDayNumber(j)
 			#expect(d.month == 2)
 			#expect(d.day == (isLeap ? 29 : 28))
 		}
@@ -53,10 +53,10 @@ import Testing
 		#expect(AstronomicalCalendar.numberOfDaysIn(month: 2, year: 1600) == 29)
 	}
 
-	@Test func changeover() {
+	@Test func changeover() throws {
 		#expect(AstronomicalCalendar.numberOfDaysIn(month: 10, year: 1582) == 21)
-		let oct1 = AstronomicalCalendar.julianDayNumberFrom(year: 1582, month: 10, day: 1)
-		let oct31 = AstronomicalCalendar.julianDayNumberFrom(year: 1582, month: 10, day: 31)
+		let oct1 = try AstronomicalCalendar.julianDayNumberFrom(year: 1582, month: 10, day: 1)
+		let oct31 = try AstronomicalCalendar.julianDayNumberFrom(year: 1582, month: 10, day: 31)
 		#expect(AstronomicalCalendar.numberOfDaysIn(month: 10, year: 1582) == (oct31 - oct1 + 1))
 
 		#expect(AstronomicalCalendar.numberOfDaysIn(month: 9, year: 1582) == JulianCalendar.numberOfDaysIn(month: 9, year: 1582))
@@ -70,15 +70,15 @@ import Testing
 		#expect(AstronomicalCalendar.isValid(year: 1582, month: 10, day: 15) == true)
 		#expect(AstronomicalCalendar.isValid(year: 1582, month: 10, day: 16) == true)
 
-		#expect(AstronomicalCalendar.dateFromJulianDayNumber(GregorianCalendar.effectiveJulianDayNumber) == (1582, 10, 15))
-		#expect(AstronomicalCalendar.julianDayNumberFrom(year: 1582, month: 10, day: 15) == GregorianCalendar.effectiveJulianDayNumber)
+		#expect(try AstronomicalCalendar.dateFromJulianDayNumber(GregorianCalendar.effectiveJulianDayNumber) == (1582, 10, 15))
+		#expect(try AstronomicalCalendar.julianDayNumberFrom(year: 1582, month: 10, day: 15) == GregorianCalendar.effectiveJulianDayNumber)
 
-		#expect(AstronomicalCalendar.dateFromJulianDayNumber(GregorianCalendar.effectiveJulianDayNumber - 1) == (1582, 10, 4))
-		#expect(AstronomicalCalendar.julianDayNumberFrom(year: 1582, month: 10, day: 4) == GregorianCalendar.effectiveJulianDayNumber - 1)
+		#expect(try AstronomicalCalendar.dateFromJulianDayNumber(GregorianCalendar.effectiveJulianDayNumber - 1) == (1582, 10, 4))
+		#expect(try AstronomicalCalendar.julianDayNumberFrom(year: 1582, month: 10, day: 4) == GregorianCalendar.effectiveJulianDayNumber - 1)
 
 		#expect(AstronomicalCalendar.numberOfDays(inYear: 1582) == 355)
-		let jan1 = AstronomicalCalendar.julianDayNumberFrom(year: 1582, month: 1, day: 1)
-		let dec31 = AstronomicalCalendar.julianDayNumberFrom(year: 1582, month: 12, day: 31)
+		let jan1 = try AstronomicalCalendar.julianDayNumberFrom(year: 1582, month: 1, day: 1)
+		let dec31 = try AstronomicalCalendar.julianDayNumberFrom(year: 1582, month: 12, day: 31)
 		#expect(AstronomicalCalendar.numberOfDays(inYear: 1582) == (dec31 - jan1 + 1))
 
 		var sum = 0
@@ -103,117 +103,117 @@ import Testing
 		#expect(AstronomicalCalendar.easter(year: 1243) == (4, 12))
 	}
 
-	@Test func julianDayNumber() {
-		#expect(AstronomicalCalendar.julianDayNumberFrom(year: -999999, month: 1, day: 1) == -363528576)
-		#expect(AstronomicalCalendar.julianDayNumberFrom(year: -99999, month: 1, day: 1) == -34803576)
-		#expect(AstronomicalCalendar.julianDayNumberFrom(year: -9999, month: 1, day: 1) == -1931076)
-		#expect(AstronomicalCalendar.julianDayNumberFrom(year: 9999, month: 12, day: 31) == 5373484)
-		#expect(AstronomicalCalendar.julianDayNumberFrom(year: 99999, month: 12, day: 31) == 38245309)
-		#expect(AstronomicalCalendar.julianDayNumberFrom(year: 999999, month: 12, day: 31) == 366963559)
-		#expect(AstronomicalCalendar.julianDayNumberFrom(year: -4712, month: 1, day: 1) == 0)
-		#expect(AstronomicalCalendar.julianDayNumberFrom(year: 1582, month: 10, day: 4) == 2299160)
-		#expect(AstronomicalCalendar.julianDayNumberFrom(year: 1582, month: 10, day: 15) == 2299161)
+	@Test func julianDayNumber() throws {
+		#expect(try AstronomicalCalendar.julianDayNumberFrom(year: -999999, month: 1, day: 1) == -363528576)
+		#expect(try AstronomicalCalendar.julianDayNumberFrom(year: -99999, month: 1, day: 1) == -34803576)
+		#expect(try AstronomicalCalendar.julianDayNumberFrom(year: -9999, month: 1, day: 1) == -1931076)
+		#expect(try AstronomicalCalendar.julianDayNumberFrom(year: 9999, month: 12, day: 31) == 5373484)
+		#expect(try AstronomicalCalendar.julianDayNumberFrom(year: 99999, month: 12, day: 31) == 38245309)
+		#expect(try AstronomicalCalendar.julianDayNumberFrom(year: 999999, month: 12, day: 31) == 366963559)
+		#expect(try AstronomicalCalendar.julianDayNumberFrom(year: -4712, month: 1, day: 1) == 0)
+		#expect(try AstronomicalCalendar.julianDayNumberFrom(year: 1582, month: 10, day: 4) == 2299160)
+		#expect(try AstronomicalCalendar.julianDayNumberFrom(year: 1582, month: 10, day: 15) == 2299161)
 		// NASA (https://ssd.jpl.nasa.gov/tools/jdc/) uses the Gregorian calendar for dates after 1582-10-04.
 		// This means that 1582-10-05 through 1582-10-14 are 10 JDN earlier than if the Julian calendar is used.
 		// AstronomicalCalendar uses a different rule and uses the Julian calendar for dates before 1582-10-15.
 		// I'm not sure why but who wants to argue with NASA?
-//		#expect(AstronomicalCalendar.julianDayNumberFrom(year: 1582, month: 10, day: 7) == 2299153)
-		#expect(AstronomicalCalendar.julianDayNumberFrom(year: 2000, month: 1, day: 1) == 2451545)
-		#expect(AstronomicalCalendar.julianDayNumberFrom(year: -5000, month: 1, day: 1) == -105192)
-
-		#expect(AstronomicalCalendar.dateFromJulianDayNumber(-363528576) == (-999999, 1, 1))
-		#expect(AstronomicalCalendar.dateFromJulianDayNumber(-34803576) == (-99999, 1, 1))
-		#expect(AstronomicalCalendar.dateFromJulianDayNumber(-1931076) == (-9999, 1, 1))
-		#expect(AstronomicalCalendar.dateFromJulianDayNumber(5373484) == (9999, 12, 31))
-		#expect(AstronomicalCalendar.dateFromJulianDayNumber(38245309) == (99999, 12, 31))
-		#expect(AstronomicalCalendar.dateFromJulianDayNumber(366963559) == (999999, 12, 31))
-		#expect(AstronomicalCalendar.dateFromJulianDayNumber(0) == (-4712, 1, 1))
-		#expect(AstronomicalCalendar.dateFromJulianDayNumber(2299160) == (1582, 10, 4))
-		#expect(AstronomicalCalendar.dateFromJulianDayNumber(2299161) == (1582, 10, 15))
-		#expect(AstronomicalCalendar.dateFromJulianDayNumber(2451545) == (2000, 1, 1))
-		#expect(AstronomicalCalendar.dateFromJulianDayNumber(-105192) == (-5000, 1, 1))
-
-		#expect(AstronomicalCalendar.julianDayNumberFrom(year: -9999, month: 1, day: 1) == JulianCalendar.julianDayNumberFrom(year: -9999, month: 1, day: 1))
-		#expect(AstronomicalCalendar.julianDayNumberFrom(year: 99999, month: 12, day: 31) != JulianCalendar.julianDayNumberFrom(year: 99999, month: 12, day: 31))
-		#expect(AstronomicalCalendar.julianDayNumberFrom(year: -4712, month: 1, day: 1) == JulianCalendar.julianDayNumberFrom(year: -4712, month: 1, day: 1))
-		#expect(AstronomicalCalendar.julianDayNumberFrom(year: 2000, month: 1, day: 1) != JulianCalendar.julianDayNumberFrom(year: 2000, month: 1, day: 1))
+//		#expect(try AstronomicalCalendar.julianDayNumberFrom(year: 1582, month: 10, day: 7) == 2299153)
+		#expect(try AstronomicalCalendar.julianDayNumberFrom(year: 2000, month: 1, day: 1) == 2451545)
+		#expect(try AstronomicalCalendar.julianDayNumberFrom(year: -5000, month: 1, day: 1) == -105192)
+
+		#expect(try AstronomicalCalendar.dateFromJulianDayNumber(-363528576) == (-999999, 1, 1))
+		#expect(try AstronomicalCalendar.dateFromJulianDayNumber(-34803576) == (-99999, 1, 1))
+		#expect(try AstronomicalCalendar.dateFromJulianDayNumber(-1931076) == (-9999, 1, 1))
+		#expect(try AstronomicalCalendar.dateFromJulianDayNumber(5373484) == (9999, 12, 31))
+		#expect(try AstronomicalCalendar.dateFromJulianDayNumber(38245309) == (99999, 12, 31))
+		#expect(try AstronomicalCalendar.dateFromJulianDayNumber(366963559) == (999999, 12, 31))
+		#expect(try AstronomicalCalendar.dateFromJulianDayNumber(0) == (-4712, 1, 1))
+		#expect(try AstronomicalCalendar.dateFromJulianDayNumber(2299160) == (1582, 10, 4))
+		#expect(try AstronomicalCalendar.dateFromJulianDayNumber(2299161) == (1582, 10, 15))
+		#expect(try AstronomicalCalendar.dateFromJulianDayNumber(2451545) == (2000, 1, 1))
+		#expect(try AstronomicalCalendar.dateFromJulianDayNumber(-105192) == (-5000, 1, 1))
+
+		#expect(try AstronomicalCalendar.julianDayNumberFrom(year: -9999, month: 1, day: 1) == JulianCalendar.julianDayNumberFrom(year: -9999, month: 1, day: 1))
+		#expect(try AstronomicalCalendar.julianDayNumberFrom(year: 99999, month: 12, day: 31) != JulianCalendar.julianDayNumberFrom(year: 99999, month: 12, day: 31))
+		#expect(try AstronomicalCalendar.julianDayNumberFrom(year: -4712, month: 1, day: 1) == JulianCalendar.julianDayNumberFrom(year: -4712, month: 1, day: 1))
+		#expect(try AstronomicalCalendar.julianDayNumberFrom(year: 2000, month: 1, day: 1) != JulianCalendar.julianDayNumberFrom(year: 2000, month: 1, day: 1))
 	}
 
-	@Test func julianDate() {
+	@Test func julianDate() throws {
 		// Values from Meeus (1998)
-		#expect(AstronomicalCalendar.julianDateFrom(year: 2000, month: 1, day: 1.5) == 2451545)
-		#expect(AstronomicalCalendar.julianDateFrom(year: 1999, month: 1, day: 1) == 2451179.5)
-		#expect(AstronomicalCalendar.julianDateFrom(year: 1987, month: 1, day: 27, hour: 0) == 2446822.5)
-		#expect(AstronomicalCalendar.julianDateFrom(year: 1987, month: 6, day: 19.5) == 2446966)
-		#expect(AstronomicalCalendar.julianDateFrom(year: 1988, month: 1, day: 27) == 2447187.5)
-		#expect(AstronomicalCalendar.julianDateFrom(year: 1988, month: 6, day: 19, hour: 12) == 2447332.0)
-		#expect(AstronomicalCalendar.julianDateFrom(year: 1900, month: 1, day: 1) == 2415020.5)
-		#expect(AstronomicalCalendar.julianDateFrom(year: 1600, month: 1, day: 1) == 2305447.5)
-		#expect(AstronomicalCalendar.julianDateFrom(year: 1600, month: 12, day: 31) == 2305812.5)
-		#expect(AstronomicalCalendar.julianDateFrom(year: 837, month: 4, day: 10.3) == 2026871.8)
-		#expect(AstronomicalCalendar.julianDateFrom(year: -123, month: 12, day: 31.0) == 1676496.5)
-		#expect(AstronomicalCalendar.julianDateFrom(year: -122, month: 1, day: 1.0) == 1676497.5)
-		#expect(AstronomicalCalendar.julianDateFrom(year: -1000, month: 7, day: 12, hour: 12) == 1356001)
-		#expect(AstronomicalCalendar.julianDateFrom(year: -1000, month: 2, day: 29) == 1355866.5)
-		#expect(AstronomicalCalendar.julianDateFrom(year: -1001, month: 8, day: 17.9) == 1355671.4)
-		#expect(AstronomicalCalendar.julianDateFrom(year: -4712, month: 1, day: 1.5) == 0)
-
-		#expect(AstronomicalCalendar.dateAndTimeFromJulianDate(2451545) == (2000, 1, 1, 12, 0, 0))
-		#expect(AstronomicalCalendar.dateAndTimeFromJulianDate(2451179.5) == (1999, 1, 1, 0, 0, 0))
-		#expect(AstronomicalCalendar.dateAndTimeFromJulianDate(2446822.5) == (1987, 1, 27, 0, 0, 0))
-		#expect(AstronomicalCalendar.dateAndTimeFromJulianDate(2446966) == (1987, 6, 19, 12, 0, 0))
-		#expect(AstronomicalCalendar.dateAndTimeFromJulianDate(2447187.5) == (1988, 1, 27, 0, 0, 0))
-		#expect(AstronomicalCalendar.dateAndTimeFromJulianDate(2447332.0) == (1988, 6, 19, 12, 0, 0))
-		#expect(AstronomicalCalendar.dateAndTimeFromJulianDate(2415020.5) == (1900, 1, 1, 0, 0, 0))
-		#expect(AstronomicalCalendar.dateAndTimeFromJulianDate(2305447.5) == (1600, 1, 1, 0, 0, 0))
-		#expect(AstronomicalCalendar.dateAndTimeFromJulianDate(2305812.5) == (1600, 12, 31, 0, 0, 0))
-//		#expect(AstronomicalCalendar.dateAndTimeFrom(2026871.8) == (837, 4, 10, 7, 12, 0))
+		#expect(try AstronomicalCalendar.julianDateFrom(year: 2000, month: 1, day: 1.5) == 2451545)
+		#expect(try AstronomicalCalendar.julianDateFrom(year: 1999, month: 1, day: 1) == 2451179.5)
+		#expect(try AstronomicalCalendar.julianDateFrom(year: 1987, month: 1, day: 27, hour: 0) == 2446822.5)
+		#expect(try AstronomicalCalendar.julianDateFrom(year: 1987, month: 6, day: 19.5) == 2446966)
+		#expect(try AstronomicalCalendar.julianDateFrom(year: 1988, month: 1, day: 27) == 2447187.5)
+		#expect(try AstronomicalCalendar.julianDateFrom(year: 1988, month: 6, day: 19, hour: 12) == 2447332.0)
+		#expect(try AstronomicalCalendar.julianDateFrom(year: 1900, month: 1, day: 1) == 2415020.5)
+		#expect(try AstronomicalCalendar.julianDateFrom(year: 1600, month: 1, day: 1) == 2305447.5)
+		#expect(try AstronomicalCalendar.julianDateFrom(year: 1600, month: 12, day: 31) == 2305812.5)
+		#expect(try AstronomicalCalendar.julianDateFrom(year: 837, month: 4, day: 10.3) == 2026871.8)
+		#expect(try AstronomicalCalendar.julianDateFrom(year: -123, month: 12, day: 31.0) == 1676496.5)
+		#expect(try AstronomicalCalendar.julianDateFrom(year: -122, month: 1, day: 1.0) == 1676497.5)
+		#expect(try AstronomicalCalendar.julianDateFrom(year: -1000, month: 7, day: 12, hour: 12) == 1356001)
+		#expect(try AstronomicalCalendar.julianDateFrom(year: -1000, month: 2, day: 29) == 1355866.5)
+		#expect(try AstronomicalCalendar.julianDateFrom(year: -1001, month: 8, day: 17.9) == 1355671.4)
+		#expect(try AstronomicalCalendar.julianDateFrom(year: -4712, month: 1, day: 1.5) == 0)
+
+		#expect(try AstronomicalCalendar.dateAndTimeFromJulianDate(2451545) == (2000, 1, 1, 12, 0, 0))
+		#expect(try AstronomicalCalendar.dateAndTimeFromJulianDate(2451179.5) == (1999, 1, 1, 0, 0, 0))
+		#expect(try AstronomicalCalendar.dateAndTimeFromJulianDate(2446822.5) == (1987, 1, 27, 0, 0, 0))
+		#expect(try AstronomicalCalendar.dateAndTimeFromJulianDate(2446966) == (1987, 6, 19, 12, 0, 0))
+		#expect(try AstronomicalCalendar.dateAndTimeFromJulianDate(2447187.5) == (1988, 1, 27, 0, 0, 0))
+		#expect(try AstronomicalCalendar.dateAndTimeFromJulianDate(2447332.0) == (1988, 6, 19, 12, 0, 0))
+		#expect(try AstronomicalCalendar.dateAndTimeFromJulianDate(2415020.5) == (1900, 1, 1, 0, 0, 0))
+		#expect(try AstronomicalCalendar.dateAndTimeFromJulianDate(2305447.5) == (1600, 1, 1, 0, 0, 0))
+		#expect(try AstronomicalCalendar.dateAndTimeFromJulianDate(2305812.5) == (1600, 12, 31, 0, 0, 0))
+//		#expect(try AstronomicalCalendar.dateAndTimeFromJulianDate(2026871.8) == (837, 4, 10, 7, 12, 0))
 		// Account for floating-point error since 2026871.8 is not perfectly representable by a double (real value is 2026871.80000000005)
-		var calendarDate = AstronomicalCalendar.dateAndTimeFromJulianDate(2026871.8)
+		var calendarDate = try AstronomicalCalendar.dateAndTimeFromJulianDate(2026871.8)
 		#expect((calendarDate.year, calendarDate.month, calendarDate.day) == (837, 4, 10))
 		var fractionalDay = fractionalDayFrom(hour: calendarDate.hour, minute: calendarDate.minute, second: calendarDate.second)
 		#expect(abs(fractionalDay - 0.3) < 0.000005) // ≈1/2 second accuracy check
-		#expect(AstronomicalCalendar.dateAndTimeFromJulianDate(1676496.5) == (-123, 12, 31, 0, 0, 0))
-		#expect(AstronomicalCalendar.dateAndTimeFromJulianDate(1676497.5) == (-122, 1, 1, 0, 0, 0))
-		#expect(AstronomicalCalendar.dateAndTimeFromJulianDate(1356001) == (-1000, 7, 12, 12, 0, 0))
-		#expect(AstronomicalCalendar.dateAndTimeFromJulianDate(1355866.5) == (-1000, 2, 29, 0, 0, 0))
-//		#expect(AstronomicalCalendar.dateAndTimeFrom(1355671.4) == (-1001, 8, 17, 21, 36, 0))
+		#expect(try AstronomicalCalendar.dateAndTimeFromJulianDate(1676496.5) == (-123, 12, 31, 0, 0, 0))
+		#expect(try AstronomicalCalendar.dateAndTimeFromJulianDate(1676497.5) == (-122, 1, 1, 0, 0, 0))
+		#expect(try AstronomicalCalendar.dateAndTimeFromJulianDate(1356001) == (-1000, 7, 12, 12, 0, 0))
+		#expect(try AstronomicalCalendar.dateAndTimeFromJulianDate(1355866.5) == (-1000, 2, 29, 0, 0, 0))
+//		#expect(try AstronomicalCalendar.dateAndTimeFromJulianDate(1355671.4) == (-1001, 8, 17, 21, 36, 0))
 		// Account for floating-point error since 1355671.4 is not perfectly representable by a double (real value is 1355671.39999999991)
-		calendarDate = AstronomicalCalendar.dateAndTimeFromJulianDate(1355671.4)
+		calendarDate = try AstronomicalCalendar.dateAndTimeFromJulianDate(1355671.4)
 		#expect((calendarDate.year, calendarDate.month, calendarDate.day) == (-1001, 8, 17))
 		fractionalDay = fractionalDayFrom(hour: calendarDate.hour, minute: calendarDate.minute, second: calendarDate.second)
 		#expect(abs(fractionalDay - 0.9) < 0.000005)  // ≈1/2 second accuracy check
-		#expect(AstronomicalCalendar.dateAndTimeFromJulianDate(0) == (-4712, 1, 1, 12, 0, 0))
-
-		#expect(AstronomicalCalendar.julianDateFrom(year: -4713, month: 12, day: 31, hour: 12) == -1)
-		#expect(AstronomicalCalendar.julianDateFrom(year: -4712, month: 1, day: 1) == -0.5)
-		#expect(AstronomicalCalendar.julianDateFrom(year: -4712, month: 1, day: 1, hour: 12) == 0)
-		#expect(AstronomicalCalendar.julianDateFrom(year: -4712, month: 1, day: 2) == 0.5)
-		#expect(AstronomicalCalendar.julianDateFrom(year: -4712, month: 1, day: 2, hour: 12) == 1)
-
-		#expect(AstronomicalCalendar.dateAndTimeFromJulianDate(-1) == (-4713, 12, 31, 12, 0, 0))
-		#expect(AstronomicalCalendar.dateAndTimeFromJulianDate(-0.5) == (-4712, 1, 1, 0, 0, 0))
-		#expect(AstronomicalCalendar.dateAndTimeFromJulianDate(0) == (-4712, 1, 1, 12, 0, 0))
-		#expect(AstronomicalCalendar.dateAndTimeFromJulianDate(0.5) == (-4712, 1, 2, 0, 0, 0))
-		#expect(AstronomicalCalendar.dateAndTimeFromJulianDate(1) == (-4712, 1, 2, 12, 0, 0))
-
-		#expect(AstronomicalCalendar.dateAndTimeFromJulianDate(-1.75) == (-4713, 12, 30, 18, 0, 0))
-		#expect(AstronomicalCalendar.dateAndTimeFromJulianDate(1.75) == (-4712, 1, 3, 6, 0, 0))
+		#expect(try AstronomicalCalendar.dateAndTimeFromJulianDate(0) == (-4712, 1, 1, 12, 0, 0))
+
+		#expect(try AstronomicalCalendar.julianDateFrom(year: -4713, month: 12, day: 31, hour: 12) == -1)
+		#expect(try AstronomicalCalendar.julianDateFrom(year: -4712, month: 1, day: 1) == -0.5)
+		#expect(try AstronomicalCalendar.julianDateFrom(year: -4712, month: 1, day: 1, hour: 12) == 0)
+		#expect(try AstronomicalCalendar.julianDateFrom(year: -4712, month: 1, day: 2) == 0.5)
+		#expect(try AstronomicalCalendar.julianDateFrom(year: -4712, month: 1, day: 2, hour: 12) == 1)
+
+		#expect(try AstronomicalCalendar.dateAndTimeFromJulianDate(-1) == (-4713, 12, 31, 12, 0, 0))
+		#expect(try AstronomicalCalendar.dateAndTimeFromJulianDate(-0.5) == (-4712, 1, 1, 0, 0, 0))
+		#expect(try AstronomicalCalendar.dateAndTimeFromJulianDate(0) == (-4712, 1, 1, 12, 0, 0))
+		#expect(try AstronomicalCalendar.dateAndTimeFromJulianDate(0.5) == (-4712, 1, 2, 0, 0, 0))
+		#expect(try AstronomicalCalendar.dateAndTimeFromJulianDate(1) == (-4712, 1, 2, 12, 0, 0))
+
+		#expect(try AstronomicalCalendar.dateAndTimeFromJulianDate(-1.75) == (-4713, 12, 30, 18, 0, 0))
+		#expect(try AstronomicalCalendar.dateAndTimeFromJulianDate(1.75) == (-4712, 1, 3, 6, 0, 0))
 	}
 
-	@Test func limits() {
-		#expect(AstronomicalCalendar.julianDateFrom(year: -999999, month: 1, day: 1) == -363528576.5)
-		#expect(AstronomicalCalendar.julianDateFrom(year: -99999, month: 1, day: 1) == -34803576.5)
-		#expect(AstronomicalCalendar.julianDateFrom(year: -9999, month: 1, day: 1) == -1931076.5)
-		#expect(AstronomicalCalendar.julianDateFrom(year: 9999, month: 12, day: 31) == 5373483.5)
-		#expect(AstronomicalCalendar.julianDateFrom(year: 99999, month: 12, day: 31) == 38245308.5)
-		#expect(AstronomicalCalendar.julianDateFrom(year: 999999, month: 12, day: 31) == 366963558.5)
-
-		#expect(AstronomicalCalendar.dateAndTimeFromJulianDate(-363528576.5) == (-999999, 1, 1, 0, 0, 0))
-		#expect(AstronomicalCalendar.dateAndTimeFromJulianDate(-34803576.5) == (-99999, 1, 1, 0, 0, 0))
-		#expect(AstronomicalCalendar.dateAndTimeFromJulianDate(-1931076.5) == (-9999, 1, 1, 0, 0, 0))
-		#expect(AstronomicalCalendar.dateAndTimeFromJulianDate(5373483.5) == (9999, 12, 31, 0, 0, 0))
-		#expect(AstronomicalCalendar.dateAndTimeFromJulianDate(38245308.5) == (99999, 12, 31, 0, 0, 0))
-		#expect(AstronomicalCalendar.dateAndTimeFromJulianDate(366963558.5) == (999999, 12, 31, 0, 0, 0))
+	@Test func limits() throws {
+		#expect(try AstronomicalCalendar.julianDateFrom(year: -999999, month: 1, day: 1) == -363528576.5)
+		#expect(try AstronomicalCalendar.julianDateFrom(year: -99999, month: 1, day: 1) == -34803576.5)
+		#expect(try AstronomicalCalendar.julianDateFrom(year: -9999, month: 1, day: 1) == -1931076.5)
+		#expect(try AstronomicalCalendar.julianDateFrom(year: 9999, month: 12, day: 31) == 5373483.5)
+		#expect(try AstronomicalCalendar.julianDateFrom(year: 99999, month: 12, day: 31) == 38245308.5)
+		#expect(try AstronomicalCalendar.julianDateFrom(year: 999999, month: 12, day: 31) == 366963558.5)
+
+		#expect(try AstronomicalCalendar.dateAndTimeFromJulianDate(-363528576.5) == (-999999, 1, 1, 0, 0, 0))
+		#expect(try AstronomicalCalendar.dateAndTimeFromJulianDate(-34803576.5) == (-99999, 1, 1, 0, 0, 0))
+		#expect(try AstronomicalCalendar.dateAndTimeFromJulianDate(-1931076.5) == (-9999, 1, 1, 0, 0, 0))
+		#expect(try AstronomicalCalendar.dateAndTimeFromJulianDate(5373483.5) == (9999, 12, 31, 0, 0, 0))
+		#expect(try AstronomicalCalendar.dateAndTimeFromJulianDate(38245308.5) == (99999, 12, 31, 0, 0, 0))
+		#expect(try AstronomicalCalendar.dateAndTimeFromJulianDate(366963558.5) == (999999, 12, 31, 0, 0, 0))
 	}
 }
diff --git a/Tests/JulianDayNumberTests/BahaiCalendarTests.swift b/Tests/JulianDayNumberTests/BahaiCalendarTests.swift
index bd487df..6e37469 100644
--- a/Tests/JulianDayNumberTests/BahaiCalendarTests.swift
+++ b/Tests/JulianDayNumberTests/BahaiCalendarTests.swift
@@ -8,9 +8,9 @@ import Testing
 @testable import JulianDayNumber
 
 @Suite struct BahaiCalendarTests {
-	@Test func epoch() {
-		#expect(BahaiCalendar.julianDayNumberFrom(year: 1, month: 1, day: 1) == BahaiCalendar.epoch)
-		#expect(BahaiCalendar.dateFromJulianDayNumber(BahaiCalendar.epoch) == (1, 1, 1))
+	@Test func epoch() throws {
+		#expect(try BahaiCalendar.julianDayNumberFrom(year: 1, month: 1, day: 1) == BahaiCalendar.epoch)
+		#expect(try BahaiCalendar.dateFromJulianDayNumber(BahaiCalendar.epoch) == (1, 1, 1))
 	}
 
 	@Test func dateValidation() {
@@ -19,7 +19,7 @@ import Testing
 		#expect(BahaiCalendar.isValid(year: 4, month: 19, day: 5))
 	}
 
-	@Test func leapYear() {
+	@Test func leapYear() throws {
 		#expect(!BahaiCalendar.isLeapYear(1))
 		#expect(BahaiCalendar.isLeapYear(4))
 		#expect(BahaiCalendar.isLeapYear(100))
@@ -34,8 +34,8 @@ import Testing
 
 		for y in -500...500 {
 			let isLeap = BahaiCalendar.isLeapYear(y)
-			let j = BahaiCalendar.julianDayNumberFrom(year: y, month: 19, day: isLeap ? 5 : 4)
-			let d = BahaiCalendar.dateFromJulianDayNumber(j)
+			let j = try BahaiCalendar.julianDayNumberFrom(year: y, month: 19, day: isLeap ? 5 : 4)
+			let d = try BahaiCalendar.dateFromJulianDayNumber(j)
 			#expect(d.month == 19)
 			#expect(d.day == (isLeap ? 5 : 4))
 		}
@@ -64,33 +64,33 @@ import Testing
 		#expect(BahaiCalendar.numberOfDays(inYear:1600) == 366)
 	}
 
-	@Test func julianDayNumber() {
-		#expect(BahaiCalendar.julianDayNumberFrom(year: 1, month: 1, day: 1) == 2394647)
+	@Test func julianDayNumber() throws {
+		#expect(try BahaiCalendar.julianDayNumberFrom(year: 1, month: 1, day: 1) == 2394647)
 	}
 
-	@Test func limits() {
-		#expect(BahaiCalendar.julianDateFrom(year: -999999, month: 1, day: 1) == -362847853.5)
-		#expect(BahaiCalendar.julianDateFrom(year: -99999, month: 1, day: 1) == -34129603.5)
-		#expect(BahaiCalendar.julianDateFrom(year: -9999, month: 1, day: 1) == -1257778.5)
-		#expect(BahaiCalendar.julianDateFrom(year: 9999, month: 20, day: 19) == 6046704.5)
-		#expect(BahaiCalendar.julianDateFrom(year: 99999, month: 20, day: 19) == 38918529.5)
-		#expect(BahaiCalendar.julianDateFrom(year: 999999, month: 20, day: 19) == 367636779.5)
+	@Test func limits() throws {
+		#expect(try BahaiCalendar.julianDateFrom(year: -999999, month: 1, day: 1) == -362847853.5)
+		#expect(try BahaiCalendar.julianDateFrom(year: -99999, month: 1, day: 1) == -34129603.5)
+		#expect(try BahaiCalendar.julianDateFrom(year: -9999, month: 1, day: 1) == -1257778.5)
+		#expect(try BahaiCalendar.julianDateFrom(year: 9999, month: 20, day: 19) == 6046704.5)
+		#expect(try BahaiCalendar.julianDateFrom(year: 99999, month: 20, day: 19) == 38918529.5)
+		#expect(try BahaiCalendar.julianDateFrom(year: 999999, month: 20, day: 19) == 367636779.5)
 
-		#expect(BahaiCalendar.dateAndTimeFromJulianDate(-362847853.5) == (-999999, 1, 1, 0, 0, 0))
-		#expect(BahaiCalendar.dateAndTimeFromJulianDate(-34129603.5) == (-99999, 1, 1, 0, 0, 0))
-		#expect(BahaiCalendar.dateAndTimeFromJulianDate(-1257778.5) == (-9999, 1, 1, 0, 0, 0))
-		#expect(BahaiCalendar.dateAndTimeFromJulianDate(6046704.5) == (9999, 20, 19, 0, 0, 0))
-		#expect(BahaiCalendar.dateAndTimeFromJulianDate(38918529.5) == (99999, 20, 19, 0, 0, 0))
-		#expect(BahaiCalendar.dateAndTimeFromJulianDate(367636779.5) == (999999, 20, 19, 0, 0, 0))
+		#expect(try BahaiCalendar.dateAndTimeFromJulianDate(-362847853.5) == (-999999, 1, 1, 0, 0, 0))
+		#expect(try BahaiCalendar.dateAndTimeFromJulianDate(-34129603.5) == (-99999, 1, 1, 0, 0, 0))
+		#expect(try BahaiCalendar.dateAndTimeFromJulianDate(-1257778.5) == (-9999, 1, 1, 0, 0, 0))
+		#expect(try BahaiCalendar.dateAndTimeFromJulianDate(6046704.5) == (9999, 20, 19, 0, 0, 0))
+		#expect(try BahaiCalendar.dateAndTimeFromJulianDate(38918529.5) == (99999, 20, 19, 0, 0, 0))
+		#expect(try BahaiCalendar.dateAndTimeFromJulianDate(367636779.5) == (999999, 20, 19, 0, 0, 0))
 	}
 
-	@Test func arithmeticLimits() {
-		let minDate = BahaiCalendar.dateFromJulianDayNumber(.min)
-		let minJ = BahaiCalendar.julianDayNumberFromDate(minDate)
+	@Test func arithmeticLimits() throws {
+		let minDate = try BahaiCalendar.dateFromJulianDayNumber(.min)
+		let minJ = try BahaiCalendar.julianDayNumberFromDate(minDate)
 		#expect(minJ == .min)
 
-		let maxDate = BahaiCalendar.dateFromJulianDayNumber(.max)
-		let maxJ = BahaiCalendar.julianDayNumberFromDate(maxDate)
+		let maxDate = try BahaiCalendar.dateFromJulianDayNumber(.max)
+		let maxJ = try BahaiCalendar.julianDayNumberFromDate(maxDate)
 		#expect(maxJ == .max)
 	}
 }
diff --git a/Tests/JulianDayNumberTests/CongruenceTests.swift b/Tests/JulianDayNumberTests/CongruenceTests.swift
index 1f56fee..3b55a42 100644
--- a/Tests/JulianDayNumberTests/CongruenceTests.swift
+++ b/Tests/JulianDayNumberTests/CongruenceTests.swift
@@ -8,29 +8,29 @@ import Testing
 @testable import JulianDayNumber
 
 @Suite struct CongruenceTests {
-	@Test func epoch() {
-		#expect(ArmenianCalendar.julianDayNumberFrom(year: 1, month: 1, day: 1) == JulianCalendar.julianDayNumberFrom(year: 552, month: 7, day: 11))
-		#expect(BahaiCalendar.julianDayNumberFrom(year: 1, month: 1, day: 1) == GregorianCalendar.julianDayNumberFrom(year: 1844, month: 3, day: 21))
-		#expect(CopticCalendar.julianDayNumberFrom(year: 1, month: 1, day: 1) == JulianCalendar.julianDayNumberFrom(year: 284, month: 8, day: 29))
-		#expect(EgyptianCalendar.julianDayNumberFrom(year: 1, month: 1, day: 1) == JulianCalendar.julianDayNumberFrom(year: -746, month: 2, day: 26))
-		#expect(EthiopianCalendar.julianDayNumberFrom(year: 1, month: 1, day: 1) == JulianCalendar.julianDayNumberFrom(year: 8, month: 8, day: 29))
-		#expect(FrenchRepublicanCalendar.julianDayNumberFrom(year: 1, month: 1, day: 1) == GregorianCalendar.julianDayNumberFrom(year: 1792, month: 9, day: 22))
-		#expect(GregorianCalendar.julianDayNumberFrom(year: 1, month: 1, day: 1) == JulianCalendar.julianDayNumberFrom(year: 1, month: 1, day: 3))
-		#expect(HebrewCalendar.julianDayNumberFrom(year: 1, month: 1, day: 1) == JulianCalendar.julianDayNumberFrom(year: -3760, month: 10, day: 7))
-		#expect(IslamicCalendar.julianDayNumberFrom(year: 1, month: 1, day: 1) == JulianCalendar.julianDayNumberFrom(year: 622, month: 7, day: 16))
-		#expect(KhwarizmianCalendar.julianDayNumberFrom(year: 1, month: 1, day: 1) == JulianCalendar.julianDayNumberFrom(year: 632, month: 6, day: 21))
-		#expect(MacedonianCalendar.julianDayNumberFrom(year: 1, month: 1, day: 1) == JulianCalendar.julianDayNumberFrom(year: -311, month: 9, day: 1))
-		#expect(MayaCalendar.julianDayNumberFromLongCount(baktun: 0, katun: 0, tun: 0, uinal: 0, kin: 0) == JulianCalendar.julianDayNumberFrom(year: -3113, month: 9, day: 6))
-		#expect(PersianCalendar.julianDayNumberFrom(year: 1, month: 1, day: 1) == JulianCalendar.julianDayNumberFrom(year: 632, month: 6, day: 16))
-		#expect(SakaCalendar.julianDayNumberFrom(year: 1, month: 1, day: 1) == JulianCalendar.julianDayNumberFrom(year: 79, month: 3, day: 24))
-		#expect(SyrianCalendar.julianDayNumberFrom(year: 1, month: 1, day: 1) == JulianCalendar.julianDayNumberFrom(year: -311, month: 10, day: 1))
+	@Test func epoch() throws {
+		#expect(try ArmenianCalendar.julianDayNumberFrom(year: 1, month: 1, day: 1) == JulianCalendar.julianDayNumberFrom(year: 552, month: 7, day: 11))
+		#expect(try BahaiCalendar.julianDayNumberFrom(year: 1, month: 1, day: 1) == GregorianCalendar.julianDayNumberFrom(year: 1844, month: 3, day: 21))
+		#expect(try CopticCalendar.julianDayNumberFrom(year: 1, month: 1, day: 1) == JulianCalendar.julianDayNumberFrom(year: 284, month: 8, day: 29))
+		#expect(try EgyptianCalendar.julianDayNumberFrom(year: 1, month: 1, day: 1) == JulianCalendar.julianDayNumberFrom(year: -746, month: 2, day: 26))
+		#expect(try EthiopianCalendar.julianDayNumberFrom(year: 1, month: 1, day: 1) == JulianCalendar.julianDayNumberFrom(year: 8, month: 8, day: 29))
+		#expect(try FrenchRepublicanCalendar.julianDayNumberFrom(year: 1, month: 1, day: 1) == GregorianCalendar.julianDayNumberFrom(year: 1792, month: 9, day: 22))
+		#expect(try GregorianCalendar.julianDayNumberFrom(year: 1, month: 1, day: 1) == JulianCalendar.julianDayNumberFrom(year: 1, month: 1, day: 3))
+		#expect(try HebrewCalendar.julianDayNumberFrom(year: 1, month: 1, day: 1) == JulianCalendar.julianDayNumberFrom(year: -3760, month: 10, day: 7))
+		#expect(try IslamicCalendar.julianDayNumberFrom(year: 1, month: 1, day: 1) == JulianCalendar.julianDayNumberFrom(year: 622, month: 7, day: 16))
+		#expect(try KhwarizmianCalendar.julianDayNumberFrom(year: 1, month: 1, day: 1) == JulianCalendar.julianDayNumberFrom(year: 632, month: 6, day: 21))
+		#expect(try MacedonianCalendar.julianDayNumberFrom(year: 1, month: 1, day: 1) == JulianCalendar.julianDayNumberFrom(year: -311, month: 9, day: 1))
+		#expect(try MayaCalendar.julianDayNumberFromLongCount(baktun: 0, katun: 0, tun: 0, uinal: 0, kin: 0) == JulianCalendar.julianDayNumberFrom(year: -3113, month: 9, day: 6))
+		#expect(try PersianCalendar.julianDayNumberFrom(year: 1, month: 1, day: 1) == JulianCalendar.julianDayNumberFrom(year: 632, month: 6, day: 16))
+		#expect(try SakaCalendar.julianDayNumberFrom(year: 1, month: 1, day: 1) == JulianCalendar.julianDayNumberFrom(year: 79, month: 3, day: 24))
+		#expect(try SyrianCalendar.julianDayNumberFrom(year: 1, month: 1, day: 1) == JulianCalendar.julianDayNumberFrom(year: -311, month: 10, day: 1))
 	}
 
-	@Test func gregorianToJulianConversion() {
-		#expect(JulianCalendar.julianDayNumberFrom(year: -9999, month: 1, day: 1) == GregorianCalendar.julianDayNumberFrom(year: -10000, month: 10, day: 16))
-		#expect(GregorianCalendar.julianDayNumberFrom(year: 99999, month: 12, day: 31) == JulianCalendar.julianDayNumberFrom(year: 99997, month: 12, day: 13))
-		#expect(JulianCalendar.julianDayNumberFrom(year: -4712, month: 1, day: 1) == GregorianCalendar.julianDayNumberFrom(year: -4713, month: 11, day: 24))
-		#expect(JulianCalendar.julianDayNumberFrom(year: 1582, month: 10, day: 4) == GregorianCalendar.julianDayNumberFrom(year: 1582, month: 10, day: 14))
-		#expect(GregorianCalendar.julianDayNumberFrom(year: 1582, month: 10, day: 15) == JulianCalendar.julianDayNumberFrom(year: 1582, month: 10, day: 5))
+	@Test func gregorianToJulianConversion() throws {
+		#expect(try JulianCalendar.julianDayNumberFrom(year: -9999, month: 1, day: 1) == GregorianCalendar.julianDayNumberFrom(year: -10000, month: 10, day: 16))
+		#expect(try GregorianCalendar.julianDayNumberFrom(year: 99999, month: 12, day: 31) == JulianCalendar.julianDayNumberFrom(year: 99997, month: 12, day: 13))
+		#expect(try JulianCalendar.julianDayNumberFrom(year: -4712, month: 1, day: 1) == GregorianCalendar.julianDayNumberFrom(year: -4713, month: 11, day: 24))
+		#expect(try JulianCalendar.julianDayNumberFrom(year: 1582, month: 10, day: 4) == GregorianCalendar.julianDayNumberFrom(year: 1582, month: 10, day: 14))
+		#expect(try GregorianCalendar.julianDayNumberFrom(year: 1582, month: 10, day: 15) == JulianCalendar.julianDayNumberFrom(year: 1582, month: 10, day: 5))
 	}
 }
diff --git a/Tests/JulianDayNumberTests/CopticCalendarTests.swift b/Tests/JulianDayNumberTests/CopticCalendarTests.swift
index 13f9ceb..1ad423a 100644
--- a/Tests/JulianDayNumberTests/CopticCalendarTests.swift
+++ b/Tests/JulianDayNumberTests/CopticCalendarTests.swift
@@ -8,9 +8,9 @@ import Testing
 @testable import JulianDayNumber
 
 @Suite struct CopticCalendarTests {
-	@Test func epoch() {
-		#expect(CopticCalendar.julianDayNumberFrom(year: 1, month: 1, day: 1) == CopticCalendar.epoch)
-		#expect(CopticCalendar.dateFromJulianDayNumber(CopticCalendar.epoch) == (1, 1, 1))
+	@Test func epoch() throws {
+		#expect(try CopticCalendar.julianDayNumberFrom(year: 1, month: 1, day: 1) == CopticCalendar.epoch)
+		#expect(try CopticCalendar.dateFromJulianDayNumber(CopticCalendar.epoch) == (1, 1, 1))
 	}
 
 	@Test func dateValidation() {
@@ -18,7 +18,7 @@ import Testing
 		#expect(!CopticCalendar.isValid(year: 1740, month: 13, day: 6))
 	}
 
-	@Test func leapYear() {
+	@Test func leapYear() throws {
 		#expect(!CopticCalendar.isLeapYear(1))
 		#expect(CopticCalendar.isLeapYear(3))
 		#expect(CopticCalendar.isLeapYear(7))
@@ -29,8 +29,8 @@ import Testing
 
 		for y in -500...500 {
 			let isLeap = CopticCalendar.isLeapYear(y)
-			let j = CopticCalendar.julianDayNumberFrom(year: y, month: 13, day: isLeap ? 6 : 5)
-			let d = CopticCalendar.dateFromJulianDayNumber(j)
+			let j = try CopticCalendar.julianDayNumberFrom(year: y, month: 13, day: isLeap ? 6 : 5)
+			let d = try CopticCalendar.dateFromJulianDayNumber(j)
 			#expect(d.month == 13)
 			#expect(d.day == (isLeap ? 6 : 5))
 		}
@@ -56,34 +56,34 @@ import Testing
 		#expect(CopticCalendar.numberOfDays(inYear: 1739) == 366)
 	}
 
-	@Test func julianDayNumber() {
-		#expect(CopticCalendar.julianDayNumberFrom(year: 1, month: 1, day: 1) == 1825030)
-		#expect(CopticCalendar.dateFromJulianDayNumber(1825030) == (1, 1, 1))
+	@Test func julianDayNumber() throws {
+		#expect(try CopticCalendar.julianDayNumberFrom(year: 1, month: 1, day: 1) == 1825030)
+		#expect(try CopticCalendar.dateFromJulianDayNumber(1825030) == (1, 1, 1))
 	}
 
-	@Test func limits() {
-		#expect(CopticCalendar.julianDateFrom(year: -999999, month: 1, day: 1) == -363424970.5)
-		#expect(CopticCalendar.julianDateFrom(year: -99999, month: 1, day: 1) == -34699970.5)
-		#expect(CopticCalendar.julianDateFrom(year: -9999, month: 1, day: 1) == -1827470.5)
-		#expect(CopticCalendar.julianDateFrom(year: 9999, month: 13, day: 5) == 5477162.5)
-		#expect(CopticCalendar.julianDateFrom(year: 99999, month: 13, day: 5) == 38349662.5)
-		#expect(CopticCalendar.julianDateFrom(year: 999999, month: 13, day: 5) == 367074662.5)
+	@Test func limits() throws {
+		#expect(try CopticCalendar.julianDateFrom(year: -999999, month: 1, day: 1) == -363424970.5)
+		#expect(try CopticCalendar.julianDateFrom(year: -99999, month: 1, day: 1) == -34699970.5)
+		#expect(try CopticCalendar.julianDateFrom(year: -9999, month: 1, day: 1) == -1827470.5)
+		#expect(try CopticCalendar.julianDateFrom(year: 9999, month: 13, day: 5) == 5477162.5)
+		#expect(try CopticCalendar.julianDateFrom(year: 99999, month: 13, day: 5) == 38349662.5)
+		#expect(try CopticCalendar.julianDateFrom(year: 999999, month: 13, day: 5) == 367074662.5)
 
-		#expect(CopticCalendar.dateAndTimeFromJulianDate(-363424970.5) == (-999999, 1, 1, 0, 0, 0))
-		#expect(CopticCalendar.dateAndTimeFromJulianDate(-34699970.5) == (-99999, 1, 1, 0, 0, 0))
-		#expect(CopticCalendar.dateAndTimeFromJulianDate(-1827470.5) == (-9999, 1, 1, 0, 0, 0))
-		#expect(CopticCalendar.dateAndTimeFromJulianDate(5477162.5) == (9999, 13, 5, 0, 0, 0))
-		#expect(CopticCalendar.dateAndTimeFromJulianDate(38349662.5) == (99999, 13, 5, 0, 0, 0))
-		#expect(CopticCalendar.dateAndTimeFromJulianDate(367074662.5) == (999999, 13, 5, 0, 0, 0))
+		#expect(try CopticCalendar.dateAndTimeFromJulianDate(-363424970.5) == (-999999, 1, 1, 0, 0, 0))
+		#expect(try CopticCalendar.dateAndTimeFromJulianDate(-34699970.5) == (-99999, 1, 1, 0, 0, 0))
+		#expect(try CopticCalendar.dateAndTimeFromJulianDate(-1827470.5) == (-9999, 1, 1, 0, 0, 0))
+		#expect(try CopticCalendar.dateAndTimeFromJulianDate(5477162.5) == (9999, 13, 5, 0, 0, 0))
+		#expect(try CopticCalendar.dateAndTimeFromJulianDate(38349662.5) == (99999, 13, 5, 0, 0, 0))
+		#expect(try CopticCalendar.dateAndTimeFromJulianDate(367074662.5) == (999999, 13, 5, 0, 0, 0))
 	}
 
-	@Test func arithmeticLimits() {
-		let minDate = CopticCalendar.dateFromJulianDayNumber(.min)
-		let minJ = CopticCalendar.julianDayNumberFromDate(minDate)
+	@Test func arithmeticLimits() throws {
+		let minDate = try CopticCalendar.dateFromJulianDayNumber(.min)
+		let minJ = try CopticCalendar.julianDayNumberFromDate(minDate)
 		#expect(minJ == .min)
 
-		let maxDate = CopticCalendar.dateFromJulianDayNumber(.max)
-		let maxJ = CopticCalendar.julianDayNumberFromDate(maxDate)
+		let maxDate = try CopticCalendar.dateFromJulianDayNumber(.max)
+		let maxJ = try CopticCalendar.julianDayNumberFromDate(maxDate)
 		#expect(maxJ == .max)
 	}
 }
diff --git a/Tests/JulianDayNumberTests/EgyptianCalendarTests.swift b/Tests/JulianDayNumberTests/EgyptianCalendarTests.swift
index cdd812f..60f27dd 100644
--- a/Tests/JulianDayNumberTests/EgyptianCalendarTests.swift
+++ b/Tests/JulianDayNumberTests/EgyptianCalendarTests.swift
@@ -8,9 +8,9 @@ import Testing
 @testable import JulianDayNumber
 
 @Suite struct EgyptianCalendarTests {
-	@Test func epoch() {
-		#expect(EgyptianCalendar.julianDayNumberFrom(year: 1, month: 1, day: 1) == EgyptianCalendar.epoch)
-		#expect(EgyptianCalendar.dateFromJulianDayNumber(EgyptianCalendar.epoch) == (1, 1, 1))
+	@Test func epoch() throws {
+		#expect(try EgyptianCalendar.julianDayNumberFrom(year: 1, month: 1, day: 1) == EgyptianCalendar.epoch)
+		#expect(try EgyptianCalendar.dateFromJulianDayNumber(EgyptianCalendar.epoch) == (1, 1, 1))
 	}
 
 	@Test func dateValidation() {
@@ -32,34 +32,34 @@ import Testing
 		#expect(EgyptianCalendar.numberOfDaysInYear == 365)
 	}
 
-	@Test func julianDayNumber() {
+	@Test func julianDayNumber() throws {
 		// From Richards
-		#expect(EgyptianCalendar.julianDayNumberFrom(year: 1, month: 1, day: 1) == 1448638)
+		#expect(try EgyptianCalendar.julianDayNumberFrom(year: 1, month: 1, day: 1) == 1448638)
 	}
 
-	@Test func limits() {
-		#expect(EgyptianCalendar.julianDateFrom(year: -999999, month: 1, day: 1) == -363551362.5)
-		#expect(EgyptianCalendar.julianDateFrom(year: -99999, month: 1, day: 1) == -35051362.5)
-		#expect(EgyptianCalendar.julianDateFrom(year: -9999, month: 1, day: 1) == -2201362.5)
-		#expect(EgyptianCalendar.julianDateFrom(year: 9999, month: 13, day: 5) == 5098271.5)
-		#expect(EgyptianCalendar.julianDateFrom(year: 99999, month: 13, day: 5) == 37948271.5)
-		#expect(EgyptianCalendar.julianDateFrom(year: 999999, month: 13, day: 5) == 366448271.5)
+	@Test func limits() throws {
+		#expect(try EgyptianCalendar.julianDateFrom(year: -999999, month: 1, day: 1) == -363551362.5)
+		#expect(try EgyptianCalendar.julianDateFrom(year: -99999, month: 1, day: 1) == -35051362.5)
+		#expect(try EgyptianCalendar.julianDateFrom(year: -9999, month: 1, day: 1) == -2201362.5)
+		#expect(try EgyptianCalendar.julianDateFrom(year: 9999, month: 13, day: 5) == 5098271.5)
+		#expect(try EgyptianCalendar.julianDateFrom(year: 99999, month: 13, day: 5) == 37948271.5)
+		#expect(try EgyptianCalendar.julianDateFrom(year: 999999, month: 13, day: 5) == 366448271.5)
 
-		#expect(EgyptianCalendar.dateAndTimeFromJulianDate(-363551362.5) == (-999999, 1, 1, 0, 0, 0))
-		#expect(EgyptianCalendar.dateAndTimeFromJulianDate(-35051362.5) == (-99999, 1, 1, 0, 0, 0))
-		#expect(EgyptianCalendar.dateAndTimeFromJulianDate(-2201362.5) == (-9999, 1, 1, 0, 0, 0))
-		#expect(EgyptianCalendar.dateAndTimeFromJulianDate(5098271.5) == (9999, 13, 5, 0, 0, 0))
-		#expect(EgyptianCalendar.dateAndTimeFromJulianDate(37948271.5) == (99999, 13, 5, 0, 0, 0))
-		#expect(EgyptianCalendar.dateAndTimeFromJulianDate(366448271.5) == (999999, 13, 5, 0, 0, 0))
+		#expect(try EgyptianCalendar.dateAndTimeFromJulianDate(-363551362.5) == (-999999, 1, 1, 0, 0, 0))
+		#expect(try EgyptianCalendar.dateAndTimeFromJulianDate(-35051362.5) == (-99999, 1, 1, 0, 0, 0))
+		#expect(try EgyptianCalendar.dateAndTimeFromJulianDate(-2201362.5) == (-9999, 1, 1, 0, 0, 0))
+		#expect(try EgyptianCalendar.dateAndTimeFromJulianDate(5098271.5) == (9999, 13, 5, 0, 0, 0))
+		#expect(try EgyptianCalendar.dateAndTimeFromJulianDate(37948271.5) == (99999, 13, 5, 0, 0, 0))
+		#expect(try EgyptianCalendar.dateAndTimeFromJulianDate(366448271.5) == (999999, 13, 5, 0, 0, 0))
 	}
 
-	@Test func arithmeticLimits() {
-		let minDate = EgyptianCalendar.dateFromJulianDayNumber(.min + 611)
-		let minJ = EgyptianCalendar.julianDayNumberFromDate(minDate)
+	@Test func arithmeticLimits() throws {
+		let minDate = try EgyptianCalendar.dateFromJulianDayNumber(.min + 611)
+		let minJ = try EgyptianCalendar.julianDayNumberFromDate(minDate)
 		#expect(minJ == .min + 611)
 
-		let maxDate = EgyptianCalendar.dateFromJulianDayNumber(.max)
-		let maxJ = EgyptianCalendar.julianDayNumberFromDate(maxDate)
+		let maxDate = try EgyptianCalendar.dateFromJulianDayNumber(.max)
+		let maxJ = try EgyptianCalendar.julianDayNumberFromDate(maxDate)
 		#expect(maxJ == .max)
 	}
 }
diff --git a/Tests/JulianDayNumberTests/EthiopianCalendarTests.swift b/Tests/JulianDayNumberTests/EthiopianCalendarTests.swift
index b34dabb..85ed836 100644
--- a/Tests/JulianDayNumberTests/EthiopianCalendarTests.swift
+++ b/Tests/JulianDayNumberTests/EthiopianCalendarTests.swift
@@ -8,9 +8,9 @@ import Testing
 @testable import JulianDayNumber
 
 @Suite struct EthiopianCalendarTests {
-	@Test func epoch() {
-		#expect(EthiopianCalendar.julianDayNumberFrom(year: 1, month: 1, day: 1) == EthiopianCalendar.epoch)
-		#expect(EthiopianCalendar.dateFromJulianDayNumber(EthiopianCalendar.epoch) == (1, 1, 1))
+	@Test func epoch() throws {
+		#expect(try EthiopianCalendar.julianDayNumberFrom(year: 1, month: 1, day: 1) == EthiopianCalendar.epoch)
+		#expect(try EthiopianCalendar.dateFromJulianDayNumber(EthiopianCalendar.epoch) == (1, 1, 1))
 	}
 
 	@Test func dateValidation() {
@@ -18,7 +18,7 @@ import Testing
 		#expect(!EthiopianCalendar.isValid(year: 2016, month: 13, day: 6))
 	}
 
-	@Test func leapYear() {
+	@Test func leapYear() throws {
 		#expect(!EthiopianCalendar.isLeapYear(1))
 		#expect(EthiopianCalendar.isLeapYear(3))
 		#expect(EthiopianCalendar.isLeapYear(7))
@@ -31,8 +31,8 @@ import Testing
 
 		for y in -500...500 {
 			let isLeap = EthiopianCalendar.isLeapYear(y)
-			let j = EthiopianCalendar.julianDayNumberFrom(year: y, month: 13, day: isLeap ? 6 : 5)
-			let d = EthiopianCalendar.dateFromJulianDayNumber(j)
+			let j = try EthiopianCalendar.julianDayNumberFrom(year: y, month: 13, day: isLeap ? 6 : 5)
+			let d = try EthiopianCalendar.dateFromJulianDayNumber(j)
 			#expect(d.month == 13)
 			#expect(d.day == (isLeap ? 6 : 5))
 		}
@@ -58,35 +58,35 @@ import Testing
 		#expect(EthiopianCalendar.numberOfDays(inYear: 1739) == 366)
 	}
 
-	@Test func julianDayNumber() {
-		#expect(EthiopianCalendar.julianDayNumberFrom(year: 1, month: 1, day: 1) == 1724221)
-		#expect(EthiopianCalendar.dateFromJulianDayNumber(1724221) == (1, 1, 1))
-		#expect(EthiopianCalendar.julianDayNumberFrom(year: 2000, month: 1, day: 1) == 2454356)
+	@Test func julianDayNumber() throws {
+		#expect(try EthiopianCalendar.julianDayNumberFrom(year: 1, month: 1, day: 1) == 1724221)
+		#expect(try EthiopianCalendar.dateFromJulianDayNumber(1724221) == (1, 1, 1))
+		#expect(try EthiopianCalendar.julianDayNumberFrom(year: 2000, month: 1, day: 1) == 2454356)
 	}
 
-	@Test func limits() {
-		#expect(EthiopianCalendar.julianDateFrom(year: -999999, month: 1, day: 1) == -363525779.5)
-		#expect(EthiopianCalendar.julianDateFrom(year: -99999, month: 1, day: 1) == -34800779.5)
-		#expect(EthiopianCalendar.julianDateFrom(year: -9999, month: 1, day: 1) == -1928279.5)
-		#expect(EthiopianCalendar.julianDateFrom(year: 9999, month: 13, day: 5) == 5376353.5)
-		#expect(EthiopianCalendar.julianDateFrom(year: 99999, month: 13, day: 5) == 38248853.5)
-		#expect(EthiopianCalendar.julianDateFrom(year: 999999, month: 13, day: 5) == 366973853.5)
+	@Test func limits() throws {
+		#expect(try EthiopianCalendar.julianDateFrom(year: -999999, month: 1, day: 1) == -363525779.5)
+		#expect(try EthiopianCalendar.julianDateFrom(year: -99999, month: 1, day: 1) == -34800779.5)
+		#expect(try EthiopianCalendar.julianDateFrom(year: -9999, month: 1, day: 1) == -1928279.5)
+		#expect(try EthiopianCalendar.julianDateFrom(year: 9999, month: 13, day: 5) == 5376353.5)
+		#expect(try EthiopianCalendar.julianDateFrom(year: 99999, month: 13, day: 5) == 38248853.5)
+		#expect(try EthiopianCalendar.julianDateFrom(year: 999999, month: 13, day: 5) == 366973853.5)
 
-		#expect(EthiopianCalendar.dateAndTimeFromJulianDate(-363525779.5) == (-999999, 1, 1, 0, 0, 0))
-		#expect(EthiopianCalendar.dateAndTimeFromJulianDate(-34800779.5) == (-99999, 1, 1, 0, 0, 0))
-		#expect(EthiopianCalendar.dateAndTimeFromJulianDate(-1928279.5) == (-9999, 1, 1, 0, 0, 0))
-		#expect(EthiopianCalendar.dateAndTimeFromJulianDate(5376353.5) == (9999, 13, 5, 0, 0, 0))
-		#expect(EthiopianCalendar.dateAndTimeFromJulianDate(38248853.5) == (99999, 13, 5, 0, 0, 0))
-		#expect(EthiopianCalendar.dateAndTimeFromJulianDate(366973853.5) == (999999, 13, 5, 0, 0, 0))
+		#expect(try EthiopianCalendar.dateAndTimeFromJulianDate(-363525779.5) == (-999999, 1, 1, 0, 0, 0))
+		#expect(try EthiopianCalendar.dateAndTimeFromJulianDate(-34800779.5) == (-99999, 1, 1, 0, 0, 0))
+		#expect(try EthiopianCalendar.dateAndTimeFromJulianDate(-1928279.5) == (-9999, 1, 1, 0, 0, 0))
+		#expect(try EthiopianCalendar.dateAndTimeFromJulianDate(5376353.5) == (9999, 13, 5, 0, 0, 0))
+		#expect(try EthiopianCalendar.dateAndTimeFromJulianDate(38248853.5) == (99999, 13, 5, 0, 0, 0))
+		#expect(try EthiopianCalendar.dateAndTimeFromJulianDate(366973853.5) == (999999, 13, 5, 0, 0, 0))
 	}
 
-	@Test func arithmeticLimits() {
-		let minDate = EthiopianCalendar.dateFromJulianDayNumber(.min)
-		let minJ = EthiopianCalendar.julianDayNumberFromDate(minDate)
+	@Test func arithmeticLimits() throws {
+		let minDate = try EthiopianCalendar.dateFromJulianDayNumber(.min)
+		let minJ = try EthiopianCalendar.julianDayNumberFromDate(minDate)
 		#expect(minJ == .min)
 
-		let maxDate = EthiopianCalendar.dateFromJulianDayNumber(.max)
-		let maxJ = EthiopianCalendar.julianDayNumberFromDate(maxDate)
+		let maxDate = try EthiopianCalendar.dateFromJulianDayNumber(.max)
+		let maxJ = try EthiopianCalendar.julianDayNumberFromDate(maxDate)
 		#expect(maxJ == .max)
 	}
 }
diff --git a/Tests/JulianDayNumberTests/FrenchRepublicanCalendarTests.swift b/Tests/JulianDayNumberTests/FrenchRepublicanCalendarTests.swift
index 0c8e164..8c91029 100644
--- a/Tests/JulianDayNumberTests/FrenchRepublicanCalendarTests.swift
+++ b/Tests/JulianDayNumberTests/FrenchRepublicanCalendarTests.swift
@@ -8,9 +8,9 @@ import Testing
 @testable import JulianDayNumber
 
 @Suite struct FrenchRepublicanCalendarTests {
-	@Test func epoch() {
-		#expect(FrenchRepublicanCalendar.julianDayNumberFrom(year: 1, month: 1, day: 1) == FrenchRepublicanCalendar.epoch)
-		#expect(FrenchRepublicanCalendar.dateFromJulianDayNumber(FrenchRepublicanCalendar.epoch) == (1, 1, 1))
+	@Test func epoch() throws {
+		#expect(try FrenchRepublicanCalendar.julianDayNumberFrom(year: 1, month: 1, day: 1) == FrenchRepublicanCalendar.epoch)
+		#expect(try FrenchRepublicanCalendar.dateFromJulianDayNumber(FrenchRepublicanCalendar.epoch) == (1, 1, 1))
 	}
 
 	@Test func dateValidation() {
@@ -19,7 +19,7 @@ import Testing
 		#expect(!FrenchRepublicanCalendar.isValid(year: 4, month: 13, day: 6))
 	}
 
-	@Test func leapYear() {
+	@Test func leapYear() throws {
 		#expect(FrenchRepublicanCalendar.isLeapYear(3))
 		#expect(FrenchRepublicanCalendar.isLeapYear(7))
 		#expect(FrenchRepublicanCalendar.isLeapYear(11))
@@ -34,8 +34,8 @@ import Testing
 
 		for y in -500...500 {
 			let isLeap = FrenchRepublicanCalendar.isLeapYear(y)
-			let j = FrenchRepublicanCalendar.julianDayNumberFrom(year: y, month: 13, day: isLeap ? 6 : 5)
-			let d = FrenchRepublicanCalendar.dateFromJulianDayNumber(j)
+			let j = try FrenchRepublicanCalendar.julianDayNumberFrom(year: y, month: 13, day: isLeap ? 6 : 5)
+			let d = try FrenchRepublicanCalendar.dateFromJulianDayNumber(j)
 			#expect(d.month == 13)
 			#expect(d.day == (isLeap ? 6 : 5))
 		}
@@ -62,33 +62,33 @@ import Testing
 		#expect(FrenchRepublicanCalendar.numberOfDays(inYear: 1600) == 365)
 	}
 
-	@Test func julianDayNumber() {
-		#expect(FrenchRepublicanCalendar.julianDayNumberFrom(year: 1, month: 1, day: 1) == 2375840)
+	@Test func julianDayNumber() throws {
+		#expect(try FrenchRepublicanCalendar.julianDayNumberFrom(year: 1, month: 1, day: 1) == 2375840)
 	}
 
-	@Test func limits() {
-		#expect(FrenchRepublicanCalendar.julianDateFrom(year: -999999, month: 1, day: 1) == -362866660.5)
-		#expect(FrenchRepublicanCalendar.julianDateFrom(year: -99999, month: 1, day: 1) == -34148410.5)
-		#expect(FrenchRepublicanCalendar.julianDateFrom(year: -9999, month: 1, day: 1) == -1276585.5)
-		#expect(FrenchRepublicanCalendar.julianDateFrom(year: 9999, month: 13, day: 6) == 6027898.5)
-		#expect(FrenchRepublicanCalendar.julianDateFrom(year: 99999, month: 13, day: 6) == 38899723.5)
-		#expect(FrenchRepublicanCalendar.julianDateFrom(year: 999999, month: 13, day: 6) == 367617973.5)
+	@Test func limits() throws {
+		#expect(try FrenchRepublicanCalendar.julianDateFrom(year: -999999, month: 1, day: 1) == -362866660.5)
+		#expect(try FrenchRepublicanCalendar.julianDateFrom(year: -99999, month: 1, day: 1) == -34148410.5)
+		#expect(try FrenchRepublicanCalendar.julianDateFrom(year: -9999, month: 1, day: 1) == -1276585.5)
+		#expect(try FrenchRepublicanCalendar.julianDateFrom(year: 9999, month: 13, day: 6) == 6027898.5)
+		#expect(try FrenchRepublicanCalendar.julianDateFrom(year: 99999, month: 13, day: 6) == 38899723.5)
+		#expect(try FrenchRepublicanCalendar.julianDateFrom(year: 999999, month: 13, day: 6) == 367617973.5)
 
-		#expect(FrenchRepublicanCalendar.dateAndTimeFromJulianDate(-362866660.5) == (-999999, 1, 1, 0, 0, 0))
-		#expect(FrenchRepublicanCalendar.dateAndTimeFromJulianDate(-34148410.5) == (-99999, 1, 1, 0, 0, 0))
-		#expect(FrenchRepublicanCalendar.dateAndTimeFromJulianDate(-1276585.5) == (-9999, 1, 1, 0, 0, 0))
-		#expect(FrenchRepublicanCalendar.dateAndTimeFromJulianDate(6027898.5) == (9999, 13, 6, 0, 0, 0))
-		#expect(FrenchRepublicanCalendar.dateAndTimeFromJulianDate(38899723.5) == (99999, 13, 6, 0, 0, 0))
-		#expect(FrenchRepublicanCalendar.dateAndTimeFromJulianDate(367617973.5) == (999999, 13, 6, 0, 0, 0))
+		#expect(try FrenchRepublicanCalendar.dateAndTimeFromJulianDate(-362866660.5) == (-999999, 1, 1, 0, 0, 0))
+		#expect(try FrenchRepublicanCalendar.dateAndTimeFromJulianDate(-34148410.5) == (-99999, 1, 1, 0, 0, 0))
+		#expect(try FrenchRepublicanCalendar.dateAndTimeFromJulianDate(-1276585.5) == (-9999, 1, 1, 0, 0, 0))
+		#expect(try FrenchRepublicanCalendar.dateAndTimeFromJulianDate(6027898.5) == (9999, 13, 6, 0, 0, 0))
+		#expect(try FrenchRepublicanCalendar.dateAndTimeFromJulianDate(38899723.5) == (99999, 13, 6, 0, 0, 0))
+		#expect(try FrenchRepublicanCalendar.dateAndTimeFromJulianDate(367617973.5) == (999999, 13, 6, 0, 0, 0))
 	}
 
-	@Test func arithmeticLimits() {
-		let minDate = FrenchRepublicanCalendar.dateFromJulianDayNumber(.min)
-		let minJ = FrenchRepublicanCalendar.julianDayNumberFromDate(minDate)
+	@Test func arithmeticLimits() throws {
+		let minDate = try FrenchRepublicanCalendar.dateFromJulianDayNumber(.min)
+		let minJ = try FrenchRepublicanCalendar.julianDayNumberFromDate(minDate)
 		#expect(minJ == .min)
 
-		let maxDate = FrenchRepublicanCalendar.dateFromJulianDayNumber(.max)
-		let maxJ = FrenchRepublicanCalendar.julianDayNumberFromDate(maxDate)
+		let maxDate = try FrenchRepublicanCalendar.dateFromJulianDayNumber(.max)
+		let maxJ = try FrenchRepublicanCalendar.julianDayNumberFromDate(maxDate)
 		#expect(maxJ == .max)
 	}
 }
diff --git a/Tests/JulianDayNumberTests/GregorianCalendarTests.swift b/Tests/JulianDayNumberTests/GregorianCalendarTests.swift
index 6cf0f1d..178e2c2 100644
--- a/Tests/JulianDayNumberTests/GregorianCalendarTests.swift
+++ b/Tests/JulianDayNumberTests/GregorianCalendarTests.swift
@@ -8,9 +8,9 @@ import Testing
 @testable import JulianDayNumber
 
 @Suite struct GregorianCalendarTests {
-	@Test func epoch() {
-		#expect(GregorianCalendar.julianDayNumberFrom(year: 1, month: 1, day: 1) == GregorianCalendar.epoch)
-		#expect(GregorianCalendar.dateFromJulianDayNumber(GregorianCalendar.epoch) == (1, 1, 1))
+	@Test func epoch() throws {
+		#expect(try GregorianCalendar.julianDayNumberFrom(year: 1, month: 1, day: 1) == GregorianCalendar.epoch)
+		#expect(try GregorianCalendar.dateFromJulianDayNumber(GregorianCalendar.epoch) == (1, 1, 1))
 	}
 
 	@Test func dateValidation() {
@@ -18,7 +18,7 @@ import Testing
 		#expect(!GregorianCalendar.isValid(year: 1700, month: 2, day: 29))
 	}
 
-	@Test func leapYear() {
+	@Test func leapYear() throws {
 		#expect(GregorianCalendar.isLeapYear(4))
 		#expect(!GregorianCalendar.isLeapYear(100))
 		#expect(GregorianCalendar.isLeapYear(1600))
@@ -35,8 +35,8 @@ import Testing
 
 		for y in 1583...2500 {
 			let isLeap = GregorianCalendar.isLeapYear(y)
-			let j = GregorianCalendar.julianDayNumberFrom(year: y, month: 2, day: isLeap ? 29 : 28)
-			let d = GregorianCalendar.dateFromJulianDayNumber(j)
+			let j = try GregorianCalendar.julianDayNumberFrom(year: y, month: 2, day: isLeap ? 29 : 28)
+			let d = try GregorianCalendar.dateFromJulianDayNumber(j)
 			#expect(d.month == 2)
 			#expect(d.day == (isLeap ? 29 : 28))
 		}
@@ -51,7 +51,7 @@ import Testing
 		#expect(GregorianCalendar.numberOfDaysIn(month: 2, year: 1700) == 28)
 	}
 
-	@Test func yearLength() {
+	@Test func yearLength() throws {
 		#expect(GregorianCalendar.numberOfDays(inYear: 4) == 366)
 		#expect(GregorianCalendar.numberOfDays(inYear: 1581) == 365)
 		#expect(GregorianCalendar.numberOfDays(inYear: 1582) == 365)
@@ -63,14 +63,14 @@ import Testing
 			sum += GregorianCalendar.numberOfDaysIn(month: m, year: 1961)
 		}
 
-		let jan1 = GregorianCalendar.julianDayNumberFrom(year: 1961, month: 1, day: 1)
-		let dec31 = GregorianCalendar.julianDayNumberFrom(year: 1961, month: 12, day: 31)
+		let jan1 = try GregorianCalendar.julianDayNumberFrom(year: 1961, month: 1, day: 1)
+		let dec31 = try GregorianCalendar.julianDayNumberFrom(year: 1961, month: 12, day: 31)
 
 		#expect(GregorianCalendar.numberOfDays(inYear: 1961) == sum)
 		#expect(sum == (dec31 - jan1 + 1))
 	}
 
-	@Test func dayOfWeek() {
+	@Test func dayOfWeek() throws {
 		#expect(GregorianCalendar.dayOfWeek(GregorianCalendar.epoch) == 2)
 		#expect(GregorianCalendar.dayOfWeek(GregorianCalendar.epoch) == GregorianCalendar.dayOfWeekFrom(year: 1, month: 1, day: 1))
 		#expect(GregorianCalendar.dayOfWeekFrom(year: -1, month: 1, day: 1) == 6)
@@ -83,7 +83,7 @@ import Testing
 		#expect(GregorianCalendar.dayOfWeek(0) == GregorianCalendar.dayOfWeekFrom(year: -4713, month: 11, day: 24))
 		#expect(GregorianCalendar.dayOfWeek(1) == GregorianCalendar.dayOfWeekFrom(year: -4713, month: 11, day: 25))
 		// Date from Meeus (1998)
-		#expect(GregorianCalendar.dayOfWeek(GregorianCalendar.julianDayNumberFrom(year: 1954, month: 6, day: 30)) == 4)
+		#expect(GregorianCalendar.dayOfWeek(try GregorianCalendar.julianDayNumberFrom(year: 1954, month: 6, day: 30)) == 4)
 		#expect(GregorianCalendar.dayOfWeek(2434924) == GregorianCalendar.dayOfWeekFrom(year: 1954, month: 6, day: 30))
 	}
 
@@ -97,61 +97,61 @@ import Testing
 		#expect(GregorianCalendar.easter(year: 1818) == (3, 22))
 	}
 
-	@Test func julianDayNumber() {
-		#expect(GregorianCalendar.julianDayNumberFrom(year: -999999, month: 1, day: 1) == -363521074)
-		#expect(GregorianCalendar.julianDayNumberFrom(year: -99999, month: 1, day: 1) == -34802824)
-		#expect(GregorianCalendar.julianDayNumberFrom(year: -9999, month: 1, day: 1) == -1930999)
-		#expect(GregorianCalendar.julianDayNumberFrom(year: 9999, month: 12, day: 31) == 5373484)
-		#expect(GregorianCalendar.julianDayNumberFrom(year: 99999, month: 12, day: 31) == 38245309)
-		#expect(GregorianCalendar.julianDayNumberFrom(year: 999999, month: 12, day: 31) == 366963559)
-		#expect(GregorianCalendar.julianDayNumberFrom(year: -4712, month: 1, day: 1) == 38)
-		#expect(GregorianCalendar.julianDayNumberFrom(year: -4713, month: 11, day: 23) == -1)
-		#expect(GregorianCalendar.julianDayNumberFrom(year: -4713, month: 11, day: 24) == 0)
-		#expect(GregorianCalendar.julianDayNumberFrom(year: -4713, month: 11, day: 25) == 1)
-		#expect(GregorianCalendar.julianDayNumberFrom(year: 1582, month: 10, day: 4) == 2299150)
-		#expect(GregorianCalendar.julianDayNumberFrom(year: 1582, month: 10, day: 15) == 2299161)
-		#expect(GregorianCalendar.julianDayNumberFrom(year: 2000, month: 1, day: 1) == 2451545)
-		#expect(GregorianCalendar.julianDayNumberFrom(year: -5000, month: 1, day: 1) == -105152)
-
-		#expect(GregorianCalendar.dateFromJulianDayNumber(-363521074) == (-999999, 1, 1))
-		#expect(GregorianCalendar.dateFromJulianDayNumber(-34802824) == (-99999, 1, 1))
-		#expect(GregorianCalendar.dateFromJulianDayNumber(-1930999) == (-9999, 1, 1))
-		#expect(GregorianCalendar.dateFromJulianDayNumber(5373484) == (9999, 12, 31))
-		#expect(GregorianCalendar.dateFromJulianDayNumber(38245309) == (99999, 12, 31))
-		#expect(GregorianCalendar.dateFromJulianDayNumber(366963559) == (999999, 12, 31))
-		#expect(GregorianCalendar.dateFromJulianDayNumber(38) == (-4712, 1, 1))
-		#expect(GregorianCalendar.dateFromJulianDayNumber(-1) == (-4713, 11, 23))
-		#expect(GregorianCalendar.dateFromJulianDayNumber(0) == (-4713, 11, 24))
-		#expect(GregorianCalendar.dateFromJulianDayNumber(1) == (-4713, 11, 25))
-		#expect(GregorianCalendar.dateFromJulianDayNumber(2299150) == (1582, 10, 4))
-		#expect(GregorianCalendar.dateFromJulianDayNumber(2299161) == (1582, 10, 15))
-		#expect(GregorianCalendar.dateFromJulianDayNumber(2451545) == (2000, 1, 1))
-		#expect(GregorianCalendar.dateFromJulianDayNumber(-105152) == (-5000, 1, 1))
+	@Test func julianDayNumber() throws {
+		#expect(try GregorianCalendar.julianDayNumberFrom(year: -999999, month: 1, day: 1) == -363521074)
+		#expect(try GregorianCalendar.julianDayNumberFrom(year: -99999, month: 1, day: 1) == -34802824)
+		#expect(try GregorianCalendar.julianDayNumberFrom(year: -9999, month: 1, day: 1) == -1930999)
+		#expect(try GregorianCalendar.julianDayNumberFrom(year: 9999, month: 12, day: 31) == 5373484)
+		#expect(try GregorianCalendar.julianDayNumberFrom(year: 99999, month: 12, day: 31) == 38245309)
+		#expect(try GregorianCalendar.julianDayNumberFrom(year: 999999, month: 12, day: 31) == 366963559)
+		#expect(try GregorianCalendar.julianDayNumberFrom(year: -4712, month: 1, day: 1) == 38)
+		#expect(try GregorianCalendar.julianDayNumberFrom(year: -4713, month: 11, day: 23) == -1)
+		#expect(try GregorianCalendar.julianDayNumberFrom(year: -4713, month: 11, day: 24) == 0)
+		#expect(try GregorianCalendar.julianDayNumberFrom(year: -4713, month: 11, day: 25) == 1)
+		#expect(try GregorianCalendar.julianDayNumberFrom(year: 1582, month: 10, day: 4) == 2299150)
+		#expect(try GregorianCalendar.julianDayNumberFrom(year: 1582, month: 10, day: 15) == 2299161)
+		#expect(try GregorianCalendar.julianDayNumberFrom(year: 2000, month: 1, day: 1) == 2451545)
+		#expect(try GregorianCalendar.julianDayNumberFrom(year: -5000, month: 1, day: 1) == -105152)
+
+		#expect(try GregorianCalendar.dateFromJulianDayNumber(-363521074) == (-999999, 1, 1))
+		#expect(try GregorianCalendar.dateFromJulianDayNumber(-34802824) == (-99999, 1, 1))
+		#expect(try GregorianCalendar.dateFromJulianDayNumber(-1930999) == (-9999, 1, 1))
+		#expect(try GregorianCalendar.dateFromJulianDayNumber(5373484) == (9999, 12, 31))
+		#expect(try GregorianCalendar.dateFromJulianDayNumber(38245309) == (99999, 12, 31))
+		#expect(try GregorianCalendar.dateFromJulianDayNumber(366963559) == (999999, 12, 31))
+		#expect(try GregorianCalendar.dateFromJulianDayNumber(38) == (-4712, 1, 1))
+		#expect(try GregorianCalendar.dateFromJulianDayNumber(-1) == (-4713, 11, 23))
+		#expect(try GregorianCalendar.dateFromJulianDayNumber(0) == (-4713, 11, 24))
+		#expect(try GregorianCalendar.dateFromJulianDayNumber(1) == (-4713, 11, 25))
+		#expect(try GregorianCalendar.dateFromJulianDayNumber(2299150) == (1582, 10, 4))
+		#expect(try GregorianCalendar.dateFromJulianDayNumber(2299161) == (1582, 10, 15))
+		#expect(try GregorianCalendar.dateFromJulianDayNumber(2451545) == (2000, 1, 1))
+		#expect(try GregorianCalendar.dateFromJulianDayNumber(-105152) == (-5000, 1, 1))
 	}
 
-	@Test func limits() {
-		#expect(GregorianCalendar.julianDateFrom(year: -999999, month: 1, day: 1) == -363521074.5)
-		#expect(GregorianCalendar.julianDateFrom(year: -99999, month: 1, day: 1) == -34802824.5)
-		#expect(GregorianCalendar.julianDateFrom(year: -9999, month: 1, day: 1) == -1930999.5)
-		#expect(GregorianCalendar.julianDateFrom(year: 9999, month: 12, day: 31) == 5373483.5)
-		#expect(GregorianCalendar.julianDateFrom(year: 99999, month: 12, day: 31) == 38245308.5)
-		#expect(GregorianCalendar.julianDateFrom(year: 999999, month: 12, day: 31) == 366963558.5)
-
-		#expect(GregorianCalendar.dateAndTimeFromJulianDate(-363521074.5) == (-999999, 1, 1, 0, 0, 0))
-		#expect(GregorianCalendar.dateAndTimeFromJulianDate(-34802824.5) == (-99999, 1, 1, 0, 0, 0))
-		#expect(GregorianCalendar.dateAndTimeFromJulianDate(-1930999.5) == (-9999, 1, 1, 0, 0, 0))
-		#expect(GregorianCalendar.dateAndTimeFromJulianDate(5373483.5) == (9999, 12, 31, 0, 0, 0))
-		#expect(GregorianCalendar.dateAndTimeFromJulianDate(38245308.5) == (99999, 12, 31, 0, 0, 0))
-		#expect(GregorianCalendar.dateAndTimeFromJulianDate(366963558.5) == (999999, 12, 31, 0, 0, 0))
+	@Test func limits() throws {
+		#expect(try GregorianCalendar.julianDateFrom(year: -999999, month: 1, day: 1) == -363521074.5)
+		#expect(try GregorianCalendar.julianDateFrom(year: -99999, month: 1, day: 1) == -34802824.5)
+		#expect(try GregorianCalendar.julianDateFrom(year: -9999, month: 1, day: 1) == -1930999.5)
+		#expect(try GregorianCalendar.julianDateFrom(year: 9999, month: 12, day: 31) == 5373483.5)
+		#expect(try GregorianCalendar.julianDateFrom(year: 99999, month: 12, day: 31) == 38245308.5)
+		#expect(try GregorianCalendar.julianDateFrom(year: 999999, month: 12, day: 31) == 366963558.5)
+
+		#expect(try GregorianCalendar.dateAndTimeFromJulianDate(-363521074.5) == (-999999, 1, 1, 0, 0, 0))
+		#expect(try GregorianCalendar.dateAndTimeFromJulianDate(-34802824.5) == (-99999, 1, 1, 0, 0, 0))
+		#expect(try GregorianCalendar.dateAndTimeFromJulianDate(-1930999.5) == (-9999, 1, 1, 0, 0, 0))
+		#expect(try GregorianCalendar.dateAndTimeFromJulianDate(5373483.5) == (9999, 12, 31, 0, 0, 0))
+		#expect(try GregorianCalendar.dateAndTimeFromJulianDate(38245308.5) == (99999, 12, 31, 0, 0, 0))
+		#expect(try GregorianCalendar.dateAndTimeFromJulianDate(366963558.5) == (999999, 12, 31, 0, 0, 0))
 	}
 
-	@Test func arithmeticLimits() {
-		let minDate = GregorianCalendar.dateFromJulianDayNumber(.min)
-		let minJ = GregorianCalendar.julianDayNumberFromDate(minDate)
+	@Test func arithmeticLimits() throws {
+		let minDate = try GregorianCalendar.dateFromJulianDayNumber(.min)
+		let minJ = try GregorianCalendar.julianDayNumberFromDate(minDate)
 		#expect(minJ == .min)
 
-		let maxDate = GregorianCalendar.dateFromJulianDayNumber(.max)
-		let maxJ = GregorianCalendar.julianDayNumberFromDate(maxDate)
+		let maxDate = try GregorianCalendar.dateFromJulianDayNumber(.max)
+		let maxJ = try GregorianCalendar.julianDayNumberFromDate(maxDate)
 		#expect(maxJ == .max)
 	}
 }
diff --git a/Tests/JulianDayNumberTests/HebrewCalendarTests.swift b/Tests/JulianDayNumberTests/HebrewCalendarTests.swift
index 2f4a75e..23cd3f5 100644
--- a/Tests/JulianDayNumberTests/HebrewCalendarTests.swift
+++ b/Tests/JulianDayNumberTests/HebrewCalendarTests.swift
@@ -84,9 +84,9 @@ import Testing
 //		#expect(HebrewCalendar.yearContaining(julianDayNumber: -364898823) == -999999)
 	}
 
-	@Test func epoch() {
-		#expect(HebrewCalendar.julianDayNumberFrom(year: 1, month: 1, day: 1) == HebrewCalendar.epoch)
-		#expect(HebrewCalendar.dateFromJulianDayNumber(HebrewCalendar.epoch) == (1, 1, 1))
+	@Test func epoch() throws {
+		#expect(try HebrewCalendar.julianDayNumberFrom(year: 1, month: 1, day: 1) == HebrewCalendar.epoch)
+		#expect(try HebrewCalendar.dateFromJulianDayNumber(HebrewCalendar.epoch) == (1, 1, 1))
 	}
 
 	@Test func dateValidation() {
@@ -207,50 +207,50 @@ import Testing
 		#expect(HebrewCalendar.numberOfDays(inYear: 19) == 383)
 	}
 
-	@Test func julianDayNumber() {
-		#expect(HebrewCalendar.julianDayNumberFrom(year: -999999, month: 1, day: 1) == -364898823)
-		#expect(HebrewCalendar.julianDayNumberFrom(year: -99999, month: 1, day: 1) == -36176711)
-		#expect(HebrewCalendar.julianDayNumberFrom(year: -9999, month: 1, day: 1) == -3304494)
-		#expect(HebrewCalendar.julianDayNumberFrom(year: 9999, month: 12, day: 29) == 4000075)
-		#expect(HebrewCalendar.julianDayNumberFrom(year: 99999, month: 12, day: 29) == 36872292)
-		#expect(HebrewCalendar.julianDayNumberFrom(year: 999999, month: 12, day: 29) == 365594434)
-		#expect(HebrewCalendar.julianDayNumberFrom(year: 2000, month: 1, day: 1) == 1078112)
-		#expect(HebrewCalendar.julianDayNumberFrom(year: -5000, month: 1, day: 1) == -1478617)
+	@Test func julianDayNumber() throws {
+		#expect(try HebrewCalendar.julianDayNumberFrom(year: -999999, month: 1, day: 1) == -364898823)
+		#expect(try HebrewCalendar.julianDayNumberFrom(year: -99999, month: 1, day: 1) == -36176711)
+		#expect(try HebrewCalendar.julianDayNumberFrom(year: -9999, month: 1, day: 1) == -3304494)
+		#expect(try HebrewCalendar.julianDayNumberFrom(year: 9999, month: 12, day: 29) == 4000075)
+		#expect(try HebrewCalendar.julianDayNumberFrom(year: 99999, month: 12, day: 29) == 36872292)
+		#expect(try HebrewCalendar.julianDayNumberFrom(year: 999999, month: 12, day: 29) == 365594434)
+		#expect(try HebrewCalendar.julianDayNumberFrom(year: 2000, month: 1, day: 1) == 1078112)
+		#expect(try HebrewCalendar.julianDayNumberFrom(year: -5000, month: 1, day: 1) == -1478617)
 
-		#expect(HebrewCalendar.dateFromJulianDayNumber(-364898823) == (-999999, 1, 1))
-		#expect(HebrewCalendar.dateFromJulianDayNumber(-36176711) == (-99999, 1, 1))
-		#expect(HebrewCalendar.dateFromJulianDayNumber(-3304494) == (-9999, 1, 1))
-		#expect(HebrewCalendar.dateFromJulianDayNumber(4000075) == (9999, 12, 29))
-		#expect(HebrewCalendar.dateFromJulianDayNumber(36872292) == (99999, 12, 29))
-		#expect(HebrewCalendar.dateFromJulianDayNumber(365594434) == (999999, 12, 29))
-		#expect(HebrewCalendar.dateFromJulianDayNumber(0) == (-952, 4, 20))
-		#expect(HebrewCalendar.dateFromJulianDayNumber(1078112) == (2000, 1, 1))
-		#expect(HebrewCalendar.dateFromJulianDayNumber(-1478617) == (-5000, 1, 1))
+		#expect(try HebrewCalendar.dateFromJulianDayNumber(-364898823) == (-999999, 1, 1))
+		#expect(try HebrewCalendar.dateFromJulianDayNumber(-36176711) == (-99999, 1, 1))
+		#expect(try HebrewCalendar.dateFromJulianDayNumber(-3304494) == (-9999, 1, 1))
+		#expect(try HebrewCalendar.dateFromJulianDayNumber(4000075) == (9999, 12, 29))
+		#expect(try HebrewCalendar.dateFromJulianDayNumber(36872292) == (99999, 12, 29))
+		#expect(try HebrewCalendar.dateFromJulianDayNumber(365594434) == (999999, 12, 29))
+		#expect(try HebrewCalendar.dateFromJulianDayNumber(0) == (-952, 4, 20))
+		#expect(try HebrewCalendar.dateFromJulianDayNumber(1078112) == (2000, 1, 1))
+		#expect(try HebrewCalendar.dateFromJulianDayNumber(-1478617) == (-5000, 1, 1))
 	}
 
-	@Test func limits() {
-		#expect(HebrewCalendar.julianDateFrom(year: -999999, month: 1, day: 1) == -364898823.5)
-		#expect(HebrewCalendar.julianDateFrom(year: -99999, month: 1, day: 1) == -36176711.5)
-		#expect(HebrewCalendar.julianDateFrom(year: -9999, month: 1, day: 1) == -3304494.5)
-		#expect(HebrewCalendar.julianDateFrom(year: 9999, month: 12, day: 29) == 4000074.5)
-		#expect(HebrewCalendar.julianDateFrom(year: 99999, month: 12, day: 29) == 36872291.5)
-		#expect(HebrewCalendar.julianDateFrom(year: 999999, month: 12, day: 29) == 365594433.5)
+	@Test func limits() throws {
+		#expect(try HebrewCalendar.julianDateFrom(year: -999999, month: 1, day: 1) == -364898823.5)
+		#expect(try HebrewCalendar.julianDateFrom(year: -99999, month: 1, day: 1) == -36176711.5)
+		#expect(try HebrewCalendar.julianDateFrom(year: -9999, month: 1, day: 1) == -3304494.5)
+		#expect(try HebrewCalendar.julianDateFrom(year: 9999, month: 12, day: 29) == 4000074.5)
+		#expect(try HebrewCalendar.julianDateFrom(year: 99999, month: 12, day: 29) == 36872291.5)
+		#expect(try HebrewCalendar.julianDateFrom(year: 999999, month: 12, day: 29) == 365594433.5)
 
-		#expect(HebrewCalendar.dateAndTimeFromJulianDate(-364898823.5) == (-999999, 1, 1, 0, 0, 0))
-		#expect(HebrewCalendar.dateAndTimeFromJulianDate(-36176711.5) == (-99999, 1, 1, 0, 0, 0))
-		#expect(HebrewCalendar.dateAndTimeFromJulianDate(-3304494.5) == (-9999, 1, 1, 0, 0, 0))
-		#expect(HebrewCalendar.dateAndTimeFromJulianDate(4000074.5) == (9999, 12, 29, 0, 0, 0))
-		#expect(HebrewCalendar.dateAndTimeFromJulianDate(36872291.5) == (99999, 12, 29, 0, 0, 0))
-		#expect(HebrewCalendar.dateAndTimeFromJulianDate(365594433.5) == (999999, 12, 29, 0, 0, 0))
+		#expect(try HebrewCalendar.dateAndTimeFromJulianDate(-364898823.5) == (-999999, 1, 1, 0, 0, 0))
+		#expect(try HebrewCalendar.dateAndTimeFromJulianDate(-36176711.5) == (-99999, 1, 1, 0, 0, 0))
+		#expect(try HebrewCalendar.dateAndTimeFromJulianDate(-3304494.5) == (-9999, 1, 1, 0, 0, 0))
+		#expect(try HebrewCalendar.dateAndTimeFromJulianDate(4000074.5) == (9999, 12, 29, 0, 0, 0))
+		#expect(try HebrewCalendar.dateAndTimeFromJulianDate(36872291.5) == (99999, 12, 29, 0, 0, 0))
+		#expect(try HebrewCalendar.dateAndTimeFromJulianDate(365594433.5) == (999999, 12, 29, 0, 0, 0))
 	}
 
-	@Test func arithmeticLimits() {
+	@Test func arithmeticLimits() throws {
 		// Values smaller than this cause an arithmetic overflow in dateFromJulianDayNumber
 //		let smallestJDNForHebrewCalendar: JulianDayNumber = .min + 106959827
 		// Values smaller than this cause an arithmetic overflow in julianDayNumberFrom
 		let smallestJDNForHebrewCalendar: JulianDayNumber = .min + 106960181
-		var (Y, M, D) = HebrewCalendar.dateFromJulianDayNumber(smallestJDNForHebrewCalendar)
-		var jdn = HebrewCalendar.julianDayNumberFrom(year: Y, month: M, day: D)
+		var (Y, M, D) = try HebrewCalendar.dateFromJulianDayNumber(smallestJDNForHebrewCalendar)
+		var jdn = try HebrewCalendar.julianDayNumberFrom(year: Y, month: M, day: D)
 		#expect(smallestJDNForHebrewCalendar == jdn)
 
 #if _pointerBitWidth(_64)
@@ -260,8 +260,8 @@ import Testing
 #else
 		let largestJDNForHebrewCalendar: JulianDayNumber = 343469932136373189
 #endif
-		(Y, M, D) = HebrewCalendar.dateFromJulianDayNumber(largestJDNForHebrewCalendar)
-		jdn = HebrewCalendar.julianDayNumberFrom(year: Y, month: M, day: D)
+		(Y, M, D) = try HebrewCalendar.dateFromJulianDayNumber(largestJDNForHebrewCalendar)
+		jdn = try HebrewCalendar.julianDayNumberFrom(year: Y, month: M, day: D)
 		#expect(largestJDNForHebrewCalendar == jdn)
 #endif
 	}
diff --git a/Tests/JulianDayNumberTests/ISOCalendarTests.swift b/Tests/JulianDayNumberTests/ISOCalendarTests.swift
index dd81b68..9cc3a32 100644
--- a/Tests/JulianDayNumberTests/ISOCalendarTests.swift
+++ b/Tests/JulianDayNumberTests/ISOCalendarTests.swift
@@ -24,33 +24,33 @@ import Testing
 		#expect(ISOCalendar.isoWeekdayFrom(year: 2023, month: 11, day: 19) == 7)
 	}
 
-	@Test func dateFrom() {
-		#expect(ISOCalendar.isoDateFrom(year: 2023, month: 11, day: 16) == (2023, 46, 4))
-		#expect(ISOCalendar.dateFromISO(year: 2023, week: 46, weekday: 4) == (2023, 11, 16))
+	@Test func dateFrom() throws {
+		#expect(try ISOCalendar.isoDateFrom(year: 2023, month: 11, day: 16) == (2023, 46, 4))
+		#expect(try ISOCalendar.dateFromISO(year: 2023, week: 46, weekday: 4) == (2023, 11, 16))
 
-		#expect(ISOCalendar.isoDateFrom(year: 2020, month: 12, day: 27) == (2020, 52, 7))
-		#expect(ISOCalendar.isoDateFrom(year: 2020, month: 12, day: 28) == (2020, 53, 1))
-		#expect(ISOCalendar.isoDateFrom(year: 2020, month: 12, day: 29) == (2020, 53, 2))
-		#expect(ISOCalendar.isoDateFrom(year: 2020, month: 12, day: 30) == (2020, 53, 3))
-		#expect(ISOCalendar.isoDateFrom(year: 2020, month: 12, day: 31) == (2020, 53, 4))
-		#expect(ISOCalendar.isoDateFrom(year: 2021, month: 1, day: 1) == (2020, 53, 5))
-		#expect(ISOCalendar.isoDateFrom(year: 2021, month: 1, day: 2) == (2020, 53, 6))
-		#expect(ISOCalendar.isoDateFrom(year: 2021, month: 1, day: 3) == (2020, 53, 7))
-		#expect(ISOCalendar.isoDateFrom(year: 2021, month: 1, day: 4) == (2021, 1, 1))
+		#expect(try ISOCalendar.isoDateFrom(year: 2020, month: 12, day: 27) == (2020, 52, 7))
+		#expect(try ISOCalendar.isoDateFrom(year: 2020, month: 12, day: 28) == (2020, 53, 1))
+		#expect(try ISOCalendar.isoDateFrom(year: 2020, month: 12, day: 29) == (2020, 53, 2))
+		#expect(try ISOCalendar.isoDateFrom(year: 2020, month: 12, day: 30) == (2020, 53, 3))
+		#expect(try ISOCalendar.isoDateFrom(year: 2020, month: 12, day: 31) == (2020, 53, 4))
+		#expect(try ISOCalendar.isoDateFrom(year: 2021, month: 1, day: 1) == (2020, 53, 5))
+		#expect(try ISOCalendar.isoDateFrom(year: 2021, month: 1, day: 2) == (2020, 53, 6))
+		#expect(try ISOCalendar.isoDateFrom(year: 2021, month: 1, day: 3) == (2020, 53, 7))
+		#expect(try ISOCalendar.isoDateFrom(year: 2021, month: 1, day: 4) == (2021, 1, 1))
 
-		#expect(ISOCalendar.dateFromISO(year: 2020, week: 52, weekday: 7) == (2020, 12, 27))
-		#expect(ISOCalendar.dateFromISO(year: 2020, week: 53, weekday: 1) == (2020, 12, 28))
-		#expect(ISOCalendar.dateFromISO(year: 2020, week: 53, weekday: 2) == (2020, 12, 29))
-		#expect(ISOCalendar.dateFromISO(year: 2020, week: 53, weekday: 3) == (2020, 12, 30))
-		#expect(ISOCalendar.dateFromISO(year: 2020, week: 53, weekday: 4) == (2020, 12, 31))
-		#expect(ISOCalendar.dateFromISO(year: 2020, week: 53, weekday: 5) == (2021, 1, 1))
-		#expect(ISOCalendar.dateFromISO(year: 2020, week: 53, weekday: 6) == (2021, 1, 2))
-		#expect(ISOCalendar.dateFromISO(year: 2020, week: 53, weekday: 7) == (2021, 1, 3))
-		#expect(ISOCalendar.dateFromISO(year: 2021, week: 1, weekday: 1) == (2021, 1, 4))
+		#expect(try ISOCalendar.dateFromISO(year: 2020, week: 52, weekday: 7) == (2020, 12, 27))
+		#expect(try ISOCalendar.dateFromISO(year: 2020, week: 53, weekday: 1) == (2020, 12, 28))
+		#expect(try ISOCalendar.dateFromISO(year: 2020, week: 53, weekday: 2) == (2020, 12, 29))
+		#expect(try ISOCalendar.dateFromISO(year: 2020, week: 53, weekday: 3) == (2020, 12, 30))
+		#expect(try ISOCalendar.dateFromISO(year: 2020, week: 53, weekday: 4) == (2020, 12, 31))
+		#expect(try ISOCalendar.dateFromISO(year: 2020, week: 53, weekday: 5) == (2021, 1, 1))
+		#expect(try ISOCalendar.dateFromISO(year: 2020, week: 53, weekday: 6) == (2021, 1, 2))
+		#expect(try ISOCalendar.dateFromISO(year: 2020, week: 53, weekday: 7) == (2021, 1, 3))
+		#expect(try ISOCalendar.dateFromISO(year: 2021, week: 1, weekday: 1) == (2021, 1, 4))
 	}
 
-	@Test func julianDayNumber() {
-		#expect(ISOCalendar.julianDayNumberFromDate((2023, 46, 4)) == 2460265)
-		#expect(ISOCalendar.dateFromJulianDayNumber(2460265) == (2023, 46, 4))
+	@Test func julianDayNumber() throws {
+		#expect(try ISOCalendar.julianDayNumberFromDate((2023, 46, 4)) == 2460265)
+		#expect(try ISOCalendar.dateFromJulianDayNumber(2460265) == (2023, 46, 4))
 	}
 }
diff --git a/Tests/JulianDayNumberTests/IslamicCalendarTests.swift b/Tests/JulianDayNumberTests/IslamicCalendarTests.swift
index 03798c6..f3f714b 100644
--- a/Tests/JulianDayNumberTests/IslamicCalendarTests.swift
+++ b/Tests/JulianDayNumberTests/IslamicCalendarTests.swift
@@ -8,9 +8,9 @@ import Testing
 @testable import JulianDayNumber
 
 @Suite struct IslamicCalendarTests {
-	@Test func epoch() {
-		#expect(IslamicCalendar.julianDayNumberFrom(year: 1, month: 1, day: 1) == IslamicCalendar.epoch)
-		#expect(IslamicCalendar.dateFromJulianDayNumber(IslamicCalendar.epoch) == (1, 1, 1))
+	@Test func epoch() throws {
+		#expect(try IslamicCalendar.julianDayNumberFrom(year: 1, month: 1, day: 1) == IslamicCalendar.epoch)
+		#expect(try IslamicCalendar.dateFromJulianDayNumber(IslamicCalendar.epoch) == (1, 1, 1))
 	}
 
 	@Test func dateValidation() {
@@ -19,7 +19,7 @@ import Testing
 		#expect(!IslamicCalendar.isValid(year: 38, month: 12, day: 30))
 	}
 
-	@Test func leapYear() {
+	@Test func leapYear() throws {
 		#expect(!IslamicCalendar.isLeapYear(1))
 		#expect(IslamicCalendar.isLeapYear(2))
 		#expect(!IslamicCalendar.isLeapYear(3))
@@ -53,8 +53,8 @@ import Testing
 
 		for y in -500...500 {
 			let isLeap = IslamicCalendar.isLeapYear(y)
-			let j = IslamicCalendar.julianDayNumberFrom(year: y, month: 12, day: isLeap ? 30 : 29)
-			let d = IslamicCalendar.dateFromJulianDayNumber(j)
+			let j = try IslamicCalendar.julianDayNumberFrom(year: y, month: 12, day: isLeap ? 30 : 29)
+			let d = try IslamicCalendar.dateFromJulianDayNumber(j)
 			#expect(d.month == 12)
 			#expect(d.day == (isLeap ? 30 : 29))
 		}
@@ -109,36 +109,36 @@ import Testing
 		#expect(IslamicCalendar.numberOfDays(inYear: 30) == 354)
 	}
 
-	@Test func julianDayNumber() {
+	@Test func julianDayNumber() throws {
 		// From Richards
-		#expect(IslamicCalendar.julianDayNumberFrom(year: 1, month: 1, day: 1) == 1948440)
+		#expect(try IslamicCalendar.julianDayNumberFrom(year: 1, month: 1, day: 1) == 1948440)
 		// From Meeus
-		#expect(IslamicCalendar.julianDayNumberFrom(year: 1421, month: 1, day: 1) == 2451641)
+		#expect(try IslamicCalendar.julianDayNumberFrom(year: 1421, month: 1, day: 1) == 2451641)
 	}
 
-	@Test func limits() {
-		#expect(IslamicCalendar.julianDateFrom(year: -999999, month: 1, day: 1) == -352418227.5)
-		#expect(IslamicCalendar.julianDateFrom(year: -99999, month: 1, day: 1) == -33488227.5)
-		#expect(IslamicCalendar.julianDateFrom(year: -9999, month: 1, day: 1) == -1595227.5)
-		#expect(IslamicCalendar.julianDateFrom(year: 9999, month: 12, day: 29) == 5491750.5)
-		#expect(IslamicCalendar.julianDateFrom(year: 99999, month: 12, day: 29) == 37384750.5)
-		#expect(IslamicCalendar.julianDateFrom(year: 999999, month: 12, day: 29) == 356314750.5)
+	@Test func limits() throws {
+		#expect(try IslamicCalendar.julianDateFrom(year: -999999, month: 1, day: 1) == -352418227.5)
+		#expect(try IslamicCalendar.julianDateFrom(year: -99999, month: 1, day: 1) == -33488227.5)
+		#expect(try IslamicCalendar.julianDateFrom(year: -9999, month: 1, day: 1) == -1595227.5)
+		#expect(try IslamicCalendar.julianDateFrom(year: 9999, month: 12, day: 29) == 5491750.5)
+		#expect(try IslamicCalendar.julianDateFrom(year: 99999, month: 12, day: 29) == 37384750.5)
+		#expect(try IslamicCalendar.julianDateFrom(year: 999999, month: 12, day: 29) == 356314750.5)
 
-		#expect(IslamicCalendar.dateAndTimeFromJulianDate(-352418227.5) == (-999999, 1, 1, 0, 0, 0))
-		#expect(IslamicCalendar.dateAndTimeFromJulianDate(-33488227.5) == (-99999, 1, 1, 0, 0, 0))
-		#expect(IslamicCalendar.dateAndTimeFromJulianDate(-1595227.5) == (-9999, 1, 1, 0, 0, 0))
-		#expect(IslamicCalendar.dateAndTimeFromJulianDate(5491750.5) == (9999, 12, 29, 0, 0, 0))
-		#expect(IslamicCalendar.dateAndTimeFromJulianDate(37384750.5) == (99999, 12, 29, 0, 0, 0))
-		#expect(IslamicCalendar.dateAndTimeFromJulianDate(356314750.5) == (999999, 12, 29, 0, 0, 0))
+		#expect(try IslamicCalendar.dateAndTimeFromJulianDate(-352418227.5) == (-999999, 1, 1, 0, 0, 0))
+		#expect(try IslamicCalendar.dateAndTimeFromJulianDate(-33488227.5) == (-99999, 1, 1, 0, 0, 0))
+		#expect(try IslamicCalendar.dateAndTimeFromJulianDate(-1595227.5) == (-9999, 1, 1, 0, 0, 0))
+		#expect(try IslamicCalendar.dateAndTimeFromJulianDate(5491750.5) == (9999, 12, 29, 0, 0, 0))
+		#expect(try IslamicCalendar.dateAndTimeFromJulianDate(37384750.5) == (99999, 12, 29, 0, 0, 0))
+		#expect(try IslamicCalendar.dateAndTimeFromJulianDate(356314750.5) == (999999, 12, 29, 0, 0, 0))
 	}
 
-	@Test func arithmeticLimits() {
-		let minDate = IslamicCalendar.dateFromJulianDayNumber(.min)
-		let minJ = IslamicCalendar.julianDayNumberFromDate(minDate)
+	@Test func arithmeticLimits() throws {
+		let minDate = try IslamicCalendar.dateFromJulianDayNumber(.min)
+		let minJ = try IslamicCalendar.julianDayNumberFromDate(minDate)
 		#expect(minJ == .min)
 
-		let maxDate = IslamicCalendar.dateFromJulianDayNumber(.max)
-		let maxJ = IslamicCalendar.julianDayNumberFromDate(maxDate)
+		let maxDate = try IslamicCalendar.dateFromJulianDayNumber(.max)
+		let maxJ = try IslamicCalendar.julianDayNumberFromDate(maxDate)
 		#expect(maxJ == .max)
 	}
 }
diff --git a/Tests/JulianDayNumberTests/JDNRoundTripTests.swift b/Tests/JulianDayNumberTests/JDNRoundTripTests.swift
index 40aa6af..b3c13af 100644
--- a/Tests/JulianDayNumberTests/JDNRoundTripTests.swift
+++ b/Tests/JulianDayNumberTests/JDNRoundTripTests.swift
@@ -19,28 +19,28 @@ import Testing
 	let maxYear = 9999
 #endif
 
-	func testCalendar<C>(_ calendar: C.Type) where C: Calendar {
+	func testCalendar<C>(_ calendar: C.Type) throws where C: Calendar {
 		for year in minYear...maxYear {
 			for month in 1...calendar.numberOfMonths(inYear: year) {
 				for day in 1...calendar.numberOfDaysIn(month: month, year: year) {
-					let jdn = calendar.julianDayNumberFrom(year: year, month: month, day: day)
-					let (Y, M, D) = calendar.dateFromJulianDayNumber(jdn)
+					let jdn = try calendar.julianDayNumberFrom(year: year, month: month, day: day)
+					let (Y, M, D) = try calendar.dateFromJulianDayNumber(jdn)
 					#expect((year, month, day) == (Y, M, D))
 				}
 			}
 		}
 	}
 
-	@Test func armenian() {
-		testCalendar(ArmenianCalendar.self)
+	@Test func armenian() throws {
+		try testCalendar(ArmenianCalendar.self)
 	}
 
-	@Test func astronomical() {
+	@Test func astronomical() throws {
 		for year in minYear...maxYear {
 			for month in 1...AstronomicalCalendar.numberOfMonths(inYear: year) {
 				for day in 1...AstronomicalCalendar.numberOfDaysIn(month: month, year: year) {
-					let jdn = AstronomicalCalendar.julianDayNumberFrom(year: year, month: month, day: day)
-					let (Y, M, D) = AstronomicalCalendar.dateFromJulianDayNumber(jdn)
+					let jdn = try AstronomicalCalendar.julianDayNumberFrom(year: year, month: month, day: day)
+					let (Y, M, D) = try AstronomicalCalendar.dateFromJulianDayNumber(jdn)
 					#expect(year == Y)
 					#expect(month == M)
 					// Handle Julian to Gregorian calendar changeover by ignoring "nonexistent" dates
@@ -53,69 +53,69 @@ import Testing
 		}
 	}
 
-	@Test func bahai() {
-		testCalendar(BahaiCalendar.self)
+	@Test func bahai() throws {
+		try testCalendar(BahaiCalendar.self)
 	}
 
-	@Test func coptic() {
-		testCalendar(CopticCalendar.self)
+	@Test func coptic() throws {
+		try testCalendar(CopticCalendar.self)
 	}
 
-	@Test func egyptian() {
-		testCalendar(EgyptianCalendar.self)
+	@Test func egyptian() throws {
+		try testCalendar(EgyptianCalendar.self)
 	}
 
-	@Test func ethiopian() {
-		testCalendar(EthiopianCalendar.self)
+	@Test func ethiopian() throws {
+		try testCalendar(EthiopianCalendar.self)
 	}
 
-	@Test func frenchRepublican() {
-		testCalendar(FrenchRepublicanCalendar.self)
+	@Test func frenchRepublican() throws {
+		try testCalendar(FrenchRepublicanCalendar.self)
 	}
 
-	@Test func gregorian() {
-		testCalendar(GregorianCalendar.self)
+	@Test func gregorian() throws {
+		try testCalendar(GregorianCalendar.self)
 	}
 
-	@Test func hebrew() {
-		testCalendar(HebrewCalendar.self)
+	@Test func hebrew() throws {
+		try testCalendar(HebrewCalendar.self)
 	}
 
-	@Test func islamic() {
-		testCalendar(IslamicCalendar.self)
+	@Test func islamic() throws {
+		try testCalendar(IslamicCalendar.self)
 	}
 
-	@Test func julian() {
-		testCalendar(JulianCalendar.self)
+	@Test func julian() throws {
+		try testCalendar(JulianCalendar.self)
 	}
 
-	@Test func khwarizmian() {
-		testCalendar(KhwarizmianCalendar.self)
+	@Test func khwarizmian() throws {
+		try testCalendar(KhwarizmianCalendar.self)
 	}
 
-	@Test func macedonian() {
-		testCalendar(MacedonianCalendar.self)
+	@Test func macedonian() throws {
+		try testCalendar(MacedonianCalendar.self)
 	}
 
-	@Test func maya() {
+	@Test func maya() throws {
 		let minJ = MayaCalendar.longCountEpoch + JulianDayNumber(minYear) * 365
 		let maxJ = MayaCalendar.longCountEpoch + JulianDayNumber(maxYear) * 365
 		for J in minJ...maxJ {
-			let (b, k, t, u, d) = MayaCalendar.longCountFromJulianDayNumber(J)
-			let jdn = MayaCalendar.julianDayNumberFromLongCount(baktun: b, katun: k, tun: t, uinal: u, kin: d)
+			let (b, k, t, u, d) = try MayaCalendar.longCountFromJulianDayNumber(J)
+			let jdn = try MayaCalendar.julianDayNumberFromLongCount(baktun: b, katun: k, tun: t, uinal: u, kin: d)
 			#expect(J == jdn)
 		}
 	}
 
-	@Test func persian() {
-		testCalendar(PersianCalendar.self)
+	@Test func persian() throws {
+		try testCalendar(PersianCalendar.self)
 	}
 
-	@Test func saka() {
-		testCalendar(SakaCalendar.self)
+	@Test func saka() throws {
+		try testCalendar(SakaCalendar.self)
 	}
 
-	@Test func syrian() {
-		testCalendar(SyrianCalendar.self)
+	@Test func syrian() throws {
+		try testCalendar(SyrianCalendar.self)
 	}
 }
diff --git a/Tests/JulianDayNumberTests/JulianCalendarTests.swift b/Tests/JulianDayNumberTests/JulianCalendarTests.swift
index 22b5517..e71616c 100644
--- a/Tests/JulianDayNumberTests/JulianCalendarTests.swift
+++ b/Tests/JulianDayNumberTests/JulianCalendarTests.swift
@@ -8,9 +8,9 @@ import Testing
 @testable import JulianDayNumber
 
 @Suite struct JulianCalendarTests {
-	@Test func epoch() {
-		#expect(JulianCalendar.julianDayNumberFrom(year: 1, month: 1, day: 1) == JulianCalendar.epoch)
-		#expect(JulianCalendar.dateFromJulianDayNumber(JulianCalendar.epoch) == (1, 1, 1))
+	@Test func epoch() throws {
+		#expect(try JulianCalendar.julianDayNumberFrom(year: 1, month: 1, day: 1) == JulianCalendar.epoch)
+		#expect(try JulianCalendar.dateFromJulianDayNumber(JulianCalendar.epoch) == (1, 1, 1))
 	}
 
 	@Test func dateValidation() {
@@ -18,7 +18,7 @@ import Testing
 		#expect(JulianCalendar.isValid(year: 1700, month: 2, day: 29))
 	}
 
-	@Test func leapYear() {
+	@Test func leapYear() throws {
 		#expect(!JulianCalendar.isLeapYear(1))
 		#expect(JulianCalendar.isLeapYear(4))
 		#expect(JulianCalendar.isLeapYear(100))
@@ -34,8 +34,8 @@ import Testing
 
 		for y in -500...1752 {
 			let isLeap = JulianCalendar.isLeapYear(y)
-			let j = JulianCalendar.julianDayNumberFrom(year: y, month: 2, day: isLeap ? 29 : 28)
-			let d = JulianCalendar.dateFromJulianDayNumber(j)
+			let j = try JulianCalendar.julianDayNumberFrom(year: y, month: 2, day: isLeap ? 29 : 28)
+			let d = try JulianCalendar.dateFromJulianDayNumber(j)
 			#expect(d.month == 2)
 			#expect(d.day == (isLeap ? 29 : 28))
 		}
@@ -58,109 +58,109 @@ import Testing
 		#expect(JulianCalendar.numberOfDays(inYear: 900) == 366)
 	}
 
-	@Test func ordinalDay() {
-		#expect(JulianCalendar.ordinalDayFrom(year: 1901, month: 1, day: 1) == 1)
-		#expect(JulianCalendar.ordinalDayFrom(year: 1901, month: 1, day: 31) == 31)
-		#expect(JulianCalendar.ordinalDayFrom(year: 1901, month: 2, day: 1) == 32)
-		#expect(JulianCalendar.ordinalDayFrom(year: 1901, month: 2, day: 28) == 59)
-		#expect(JulianCalendar.ordinalDayFrom(year: 1901, month: 3, day: 1) == 60)
-		#expect(JulianCalendar.ordinalDayFrom(year: 1901, month: 3, day: 31) == 90)
-		#expect(JulianCalendar.ordinalDayFrom(year: 1901, month: 4, day: 1) == 91)
-		#expect(JulianCalendar.ordinalDayFrom(year: 1901, month: 4, day: 30) == 120)
-		#expect(JulianCalendar.ordinalDayFrom(year: 1901, month: 5, day: 1) == 121)
-		#expect(JulianCalendar.ordinalDayFrom(year: 1901, month: 5, day: 31) == 151)
-		#expect(JulianCalendar.ordinalDayFrom(year: 1901, month: 6, day: 1) == 152)
-		#expect(JulianCalendar.ordinalDayFrom(year: 1901, month: 6, day: 30) == 181)
-		#expect(JulianCalendar.ordinalDayFrom(year: 1901, month: 7, day: 1) == 182)
-		#expect(JulianCalendar.ordinalDayFrom(year: 1901, month: 7, day: 31) == 212)
-		#expect(JulianCalendar.ordinalDayFrom(year: 1901, month: 8, day: 1) == 213)
-		#expect(JulianCalendar.ordinalDayFrom(year: 1901, month: 8, day: 31) == 243)
-		#expect(JulianCalendar.ordinalDayFrom(year: 1901, month: 9, day: 1) == 244)
-		#expect(JulianCalendar.ordinalDayFrom(year: 1901, month: 9, day: 30) == 273)
-		#expect(JulianCalendar.ordinalDayFrom(year: 1901, month: 10, day: 1) == 274)
-		#expect(JulianCalendar.ordinalDayFrom(year: 1901, month: 10, day: 31) == 304)
-		#expect(JulianCalendar.ordinalDayFrom(year: 1901, month: 11, day: 1) == 305)
-		#expect(JulianCalendar.ordinalDayFrom(year: 1901, month: 11, day: 30) == 334)
-		#expect(JulianCalendar.ordinalDayFrom(year: 1901, month: 12, day: 1) == 335)
-		#expect(JulianCalendar.ordinalDayFrom(year: 1901, month: 12, day: 31) == 365)
-
-		#expect(JulianCalendar.dateFrom(year: 1901, ordinalDay: 1) == (1901, 1, 1))
-		#expect(JulianCalendar.dateFrom(year: 1901, ordinalDay: 31) == (1901, 1, 31))
-		#expect(JulianCalendar.dateFrom(year: 1901, ordinalDay: 32) == (1901, 2, 1))
-		#expect(JulianCalendar.dateFrom(year: 1901, ordinalDay: 59) == (1901, 2, 28))
-		#expect(JulianCalendar.dateFrom(year: 1901, ordinalDay: 60) == (1901, 3, 1))
-		#expect(JulianCalendar.dateFrom(year: 1901, ordinalDay: 90) == (1901, 3, 31))
-		#expect(JulianCalendar.dateFrom(year: 1901, ordinalDay: 91) == (1901, 4, 1))
-		#expect(JulianCalendar.dateFrom(year: 1901, ordinalDay: 120) == (1901, 4, 30))
-		#expect(JulianCalendar.dateFrom(year: 1901, ordinalDay: 121) == (1901, 5, 1))
-		#expect(JulianCalendar.dateFrom(year: 1901, ordinalDay: 151) == (1901, 5, 31))
-		#expect(JulianCalendar.dateFrom(year: 1901, ordinalDay: 152) == (1901, 6, 1))
-		#expect(JulianCalendar.dateFrom(year: 1901, ordinalDay: 181) == (1901, 6, 30))
-		#expect(JulianCalendar.dateFrom(year: 1901, ordinalDay: 182) == (1901, 7, 1))
-		#expect(JulianCalendar.dateFrom(year: 1901, ordinalDay: 212) == (1901, 7, 31))
-		#expect(JulianCalendar.dateFrom(year: 1901, ordinalDay: 213) == (1901, 8, 1))
-		#expect(JulianCalendar.dateFrom(year: 1901, ordinalDay: 243) == (1901, 8, 31))
-		#expect(JulianCalendar.dateFrom(year: 1901, ordinalDay: 244) == (1901, 9, 1))
-		#expect(JulianCalendar.dateFrom(year: 1901, ordinalDay: 273) == (1901, 9, 30))
-		#expect(JulianCalendar.dateFrom(year: 1901, ordinalDay: 274) == (1901, 10, 1))
-		#expect(JulianCalendar.dateFrom(year: 1901, ordinalDay: 304) == (1901, 10, 31))
-		#expect(JulianCalendar.dateFrom(year: 1901, ordinalDay: 305) == (1901, 11, 1))
-		#expect(JulianCalendar.dateFrom(year: 1901, ordinalDay: 334) == (1901, 11, 30))
-		#expect(JulianCalendar.dateFrom(year: 1901, ordinalDay: 335) == (1901, 12, 1))
-		#expect(JulianCalendar.dateFrom(year: 1901, ordinalDay: 365) == (1901, 12, 31))
-
-		#expect(JulianCalendar.ordinalDayFrom(year: 2000, month: 1, day: 1) == 1)
-		#expect(JulianCalendar.ordinalDayFrom(year: 2000, month: 1, day: 31) == 31)
-		#expect(JulianCalendar.ordinalDayFrom(year: 2000, month: 2, day: 1) == 32)
-		#expect(JulianCalendar.ordinalDayFrom(year: 2000, month: 2, day: 29) == 60)
-		#expect(JulianCalendar.ordinalDayFrom(year: 2000, month: 3, day: 1) == 61)
-		#expect(JulianCalendar.ordinalDayFrom(year: 2000, month: 3, day: 31) == 91)
-		#expect(JulianCalendar.ordinalDayFrom(year: 2000, month: 4, day: 1) == 92)
-		#expect(JulianCalendar.ordinalDayFrom(year: 2000, month: 4, day: 30) == 121)
-		#expect(JulianCalendar.ordinalDayFrom(year: 2000, month: 5, day: 1) == 122)
-		#expect(JulianCalendar.ordinalDayFrom(year: 2000, month: 5, day: 31) == 152)
-		#expect(JulianCalendar.ordinalDayFrom(year: 2000, month: 6, day: 1) == 153)
-		#expect(JulianCalendar.ordinalDayFrom(year: 2000, month: 6, day: 30) == 182)
-		#expect(JulianCalendar.ordinalDayFrom(year: 2000, month: 7, day: 1) == 183)
-		#expect(JulianCalendar.ordinalDayFrom(year: 2000, month: 7, day: 31) == 213)
-		#expect(JulianCalendar.ordinalDayFrom(year: 2000, month: 8, day: 1) == 214)
-		#expect(JulianCalendar.ordinalDayFrom(year: 2000, month: 8, day: 31) == 244)
-		#expect(JulianCalendar.ordinalDayFrom(year: 2000, month: 9, day: 1) == 245)
-		#expect(JulianCalendar.ordinalDayFrom(year: 2000, month: 9, day: 30) == 274)
-		#expect(JulianCalendar.ordinalDayFrom(year: 2000, month: 10, day: 1) == 275)
-		#expect(JulianCalendar.ordinalDayFrom(year: 2000, month: 10, day: 31) == 305)
-		#expect(JulianCalendar.ordinalDayFrom(year: 2000, month: 11, day: 1) == 306)
-		#expect(JulianCalendar.ordinalDayFrom(year: 2000, month: 11, day: 30) == 335)
-		#expect(JulianCalendar.ordinalDayFrom(year: 2000, month: 12, day: 1) == 336)
-		#expect(JulianCalendar.ordinalDayFrom(year: 2000, month: 12, day: 31) == 366)
-
-		#expect(JulianCalendar.dateFrom(year: 2000, ordinalDay: 1) == (2000, 1, 1))
-		#expect(JulianCalendar.dateFrom(year: 2000, ordinalDay: 31) == (2000, 1, 31))
-		#expect(JulianCalendar.dateFrom(year: 2000, ordinalDay: 32) == (2000, 2, 1))
-		#expect(JulianCalendar.dateFrom(year: 2000, ordinalDay: 60) == (2000, 2, 29))
-		#expect(JulianCalendar.dateFrom(year: 2000, ordinalDay: 61) == (2000, 3, 1))
-		#expect(JulianCalendar.dateFrom(year: 2000, ordinalDay: 91) == (2000, 3, 31))
-		#expect(JulianCalendar.dateFrom(year: 2000, ordinalDay: 92) == (2000, 4, 1))
-		#expect(JulianCalendar.dateFrom(year: 2000, ordinalDay: 121) == (2000, 4, 30))
-		#expect(JulianCalendar.dateFrom(year: 2000, ordinalDay: 122) == (2000, 5, 1))
-		#expect(JulianCalendar.dateFrom(year: 2000, ordinalDay: 152) == (2000, 5, 31))
-		#expect(JulianCalendar.dateFrom(year: 2000, ordinalDay: 153) == (2000, 6, 1))
-		#expect(JulianCalendar.dateFrom(year: 2000, ordinalDay: 182) == (2000, 6, 30))
-		#expect(JulianCalendar.dateFrom(year: 2000, ordinalDay: 183) == (2000, 7, 1))
-		#expect(JulianCalendar.dateFrom(year: 2000, ordinalDay: 213) == (2000, 7, 31))
-		#expect(JulianCalendar.dateFrom(year: 2000, ordinalDay: 214) == (2000, 8, 1))
-		#expect(JulianCalendar.dateFrom(year: 2000, ordinalDay: 244) == (2000, 8, 31))
-		#expect(JulianCalendar.dateFrom(year: 2000, ordinalDay: 245) == (2000, 9, 1))
-		#expect(JulianCalendar.dateFrom(year: 2000, ordinalDay: 274) == (2000, 9, 30))
-		#expect(JulianCalendar.dateFrom(year: 2000, ordinalDay: 275) == (2000, 10, 1))
-		#expect(JulianCalendar.dateFrom(year: 2000, ordinalDay: 305) == (2000, 10, 31))
-		#expect(JulianCalendar.dateFrom(year: 2000, ordinalDay: 306) == (2000, 11, 1))
-		#expect(JulianCalendar.dateFrom(year: 2000, ordinalDay: 335) == (2000, 11, 30))
-		#expect(JulianCalendar.dateFrom(year: 2000, ordinalDay: 336) == (2000, 12, 1))
-		#expect(JulianCalendar.dateFrom(year: 2000, ordinalDay: 366) == (2000, 12, 31))
+	@Test func ordinalDay() throws {
+		#expect(try JulianCalendar.ordinalDayFrom(year: 1901, month: 1, day: 1) == 1)
+		#expect(try JulianCalendar.ordinalDayFrom(year: 1901, month: 1, day: 31) == 31)
+		#expect(try JulianCalendar.ordinalDayFrom(year: 1901, month: 2, day: 1) == 32)
+		#expect(try JulianCalendar.ordinalDayFrom(year: 1901, month: 2, day: 28) == 59)
+		#expect(try JulianCalendar.ordinalDayFrom(year: 1901, month: 3, day: 1) == 60)
+		#expect(try JulianCalendar.ordinalDayFrom(year: 1901, month: 3, day: 31) == 90)
+		#expect(try JulianCalendar.ordinalDayFrom(year: 1901, month: 4, day: 1) == 91)
+		#expect(try JulianCalendar.ordinalDayFrom(year: 1901, month: 4, day: 30) == 120)
+		#expect(try JulianCalendar.ordinalDayFrom(year: 1901, month: 5, day: 1) == 121)
+		#expect(try JulianCalendar.ordinalDayFrom(year: 1901, month: 5, day: 31) == 151)
+		#expect(try JulianCalendar.ordinalDayFrom(year: 1901, month: 6, day: 1) == 152)
+		#expect(try JulianCalendar.ordinalDayFrom(year: 1901, month: 6, day: 30) == 181)
+		#expect(try JulianCalendar.ordinalDayFrom(year: 1901, month: 7, day: 1) == 182)
+		#expect(try JulianCalendar.ordinalDayFrom(year: 1901, month: 7, day: 31) == 212)
+		#expect(try JulianCalendar.ordinalDayFrom(year: 1901, month: 8, day: 1) == 213)
+		#expect(try JulianCalendar.ordinalDayFrom(year: 1901, month: 8, day: 31) == 243)
+		#expect(try JulianCalendar.ordinalDayFrom(year: 1901, month: 9, day: 1) == 244)
+		#expect(try JulianCalendar.ordinalDayFrom(year: 1901, month: 9, day: 30) == 273)
+		#expect(try JulianCalendar.ordinalDayFrom(year: 1901, month: 10, day: 1) == 274)
+		#expect(try JulianCalendar.ordinalDayFrom(year: 1901, month: 10, day: 31) == 304)
+		#expect(try JulianCalendar.ordinalDayFrom(year: 1901, month: 11, day: 1) == 305)
+		#expect(try JulianCalendar.ordinalDayFrom(year: 1901, month: 11, day: 30) == 334)
+		#expect(try JulianCalendar.ordinalDayFrom(year: 1901, month: 12, day: 1) == 335)
+		#expect(try JulianCalendar.ordinalDayFrom(year: 1901, month: 12, day: 31) == 365)
+
+		#expect(try JulianCalendar.dateFrom(year: 1901, ordinalDay: 1) == (1901, 1, 1))
+		#expect(try JulianCalendar.dateFrom(year: 1901, ordinalDay: 31) == (1901, 1, 31))
+		#expect(try JulianCalendar.dateFrom(year: 1901, ordinalDay: 32) == (1901, 2, 1))
+		#expect(try JulianCalendar.dateFrom(year: 1901, ordinalDay: 59) == (1901, 2, 28))
+		#expect(try JulianCalendar.dateFrom(year: 1901, ordinalDay: 60) == (1901, 3, 1))
+		#expect(try JulianCalendar.dateFrom(year: 1901, ordinalDay: 90) == (1901, 3, 31))
+		#expect(try JulianCalendar.dateFrom(year: 1901, ordinalDay: 91) == (1901, 4, 1))
+		#expect(try JulianCalendar.dateFrom(year: 1901, ordinalDay: 120) == (1901, 4, 30))
+		#expect(try JulianCalendar.dateFrom(year: 1901, ordinalDay: 121) == (1901, 5, 1))
+		#expect(try JulianCalendar.dateFrom(year: 1901, ordinalDay: 151) == (1901, 5, 31))
+		#expect(try JulianCalendar.dateFrom(year: 1901, ordinalDay: 152) == (1901, 6, 1))
+		#expect(try JulianCalendar.dateFrom(year: 1901, ordinalDay: 181) == (1901, 6, 30))
+		#expect(try JulianCalendar.dateFrom(year: 1901, ordinalDay: 182) == (1901, 7, 1))
+		#expect(try JulianCalendar.dateFrom(year: 1901, ordinalDay: 212) == (1901, 7, 31))
+		#expect(try JulianCalendar.dateFrom(year: 1901, ordinalDay: 213) == (1901, 8, 1))
+		#expect(try JulianCalendar.dateFrom(year: 1901, ordinalDay: 243) == (1901, 8, 31))
+		#expect(try JulianCalendar.dateFrom(year: 1901, ordinalDay: 244) == (1901, 9, 1))
+		#expect(try JulianCalendar.dateFrom(year: 1901, ordinalDay: 273) == (1901, 9, 30))
+		#expect(try JulianCalendar.dateFrom(year: 1901, ordinalDay: 274) == (1901, 10, 1))
+		#expect(try JulianCalendar.dateFrom(year: 1901, ordinalDay: 304) == (1901, 10, 31))
+		#expect(try JulianCalendar.dateFrom(year: 1901, ordinalDay: 305) == (1901, 11, 1))
+		#expect(try JulianCalendar.dateFrom(year: 1901, ordinalDay: 334) == (1901, 11, 30))
+		#expect(try JulianCalendar.dateFrom(year: 1901, ordinalDay: 335) == (1901, 12, 1))
+		#expect(try JulianCalendar.dateFrom(year: 1901, ordinalDay: 365) == (1901, 12, 31))
+
+		#expect(try JulianCalendar.ordinalDayFrom(year: 2000, month: 1, day: 1) == 1)
+		#expect(try JulianCalendar.ordinalDayFrom(year: 2000, month: 1, day: 31) == 31)
+		#expect(try JulianCalendar.ordinalDayFrom(year: 2000, month: 2, day: 1) == 32)
+		#expect(try JulianCalendar.ordinalDayFrom(year: 2000, month: 2, day: 29) == 60)
+		#expect(try JulianCalendar.ordinalDayFrom(year: 2000, month: 3, day: 1) == 61)
+		#expect(try JulianCalendar.ordinalDayFrom(year: 2000, month: 3, day: 31) == 91)
+		#expect(try JulianCalendar.ordinalDayFrom(year: 2000, month: 4, day: 1) == 92)
+		#expect(try JulianCalendar.ordinalDayFrom(year: 2000, month: 4, day: 30) == 121)
+		#expect(try JulianCalendar.ordinalDayFrom(year: 2000, month: 5, day: 1) == 122)
+		#expect(try JulianCalendar.ordinalDayFrom(year: 2000, month: 5, day: 31) == 152)
+		#expect(try JulianCalendar.ordinalDayFrom(year: 2000, month: 6, day: 1) == 153)
+		#expect(try JulianCalendar.ordinalDayFrom(year: 2000, month: 6, day: 30) == 182)
+		#expect(try JulianCalendar.ordinalDayFrom(year: 2000, month: 7, day: 1) == 183)
+		#expect(try JulianCalendar.ordinalDayFrom(year: 2000, month: 7, day: 31) == 213)
+		#expect(try JulianCalendar.ordinalDayFrom(year: 2000, month: 8, day: 1) == 214)
+		#expect(try JulianCalendar.ordinalDayFrom(year: 2000, month: 8, day: 31) == 244)
+		#expect(try JulianCalendar.ordinalDayFrom(year: 2000, month: 9, day: 1) == 245)
+		#expect(try JulianCalendar.ordinalDayFrom(year: 2000, month: 9, day: 30) == 274)
+		#expect(try JulianCalendar.ordinalDayFrom(year: 2000, month: 10, day: 1) == 275)
+		#expect(try JulianCalendar.ordinalDayFrom(year: 2000, month: 10, day: 31) == 305)
+		#expect(try JulianCalendar.ordinalDayFrom(year: 2000, month: 11, day: 1) == 306)
+		#expect(try JulianCalendar.ordinalDayFrom(year: 2000, month: 11, day: 30) == 335)
+		#expect(try JulianCalendar.ordinalDayFrom(year: 2000, month: 12, day: 1) == 336)
+		#expect(try JulianCalendar.ordinalDayFrom(year: 2000, month: 12, day: 31) == 366)
+
+		#expect(try JulianCalendar.dateFrom(year: 2000, ordinalDay: 1) == (2000, 1, 1))
+		#expect(try JulianCalendar.dateFrom(year: 2000, ordinalDay: 31) == (2000, 1, 31))
+		#expect(try JulianCalendar.dateFrom(year: 2000, ordinalDay: 32) == (2000, 2, 1))
+		#expect(try JulianCalendar.dateFrom(year: 2000, ordinalDay: 60) == (2000, 2, 29))
+		#expect(try JulianCalendar.dateFrom(year: 2000, ordinalDay: 61) == (2000, 3, 1))
+		#expect(try JulianCalendar.dateFrom(year: 2000, ordinalDay: 91) == (2000, 3, 31))
+		#expect(try JulianCalendar.dateFrom(year: 2000, ordinalDay: 92) == (2000, 4, 1))
+		#expect(try JulianCalendar.dateFrom(year: 2000, ordinalDay: 121) == (2000, 4, 30))
+		#expect(try JulianCalendar.dateFrom(year: 2000, ordinalDay: 122) == (2000, 5, 1))
+		#expect(try JulianCalendar.dateFrom(year: 2000, ordinalDay: 152) == (2000, 5, 31))
+		#expect(try JulianCalendar.dateFrom(year: 2000, ordinalDay: 153) == (2000, 6, 1))
+		#expect(try JulianCalendar.dateFrom(year: 2000, ordinalDay: 182) == (2000, 6, 30))
+		#expect(try JulianCalendar.dateFrom(year: 2000, ordinalDay: 183) == (2000, 7, 1))
+		#expect(try JulianCalendar.dateFrom(year: 2000, ordinalDay: 213) == (2000, 7, 31))
+		#expect(try JulianCalendar.dateFrom(year: 2000, ordinalDay: 214) == (2000, 8, 1))
+		#expect(try JulianCalendar.dateFrom(year: 2000, ordinalDay: 244) == (2000, 8, 31))
+		#expect(try JulianCalendar.dateFrom(year: 2000, ordinalDay: 245) == (2000, 9, 1))
+		#expect(try JulianCalendar.dateFrom(year: 2000, ordinalDay: 274) == (2000, 9, 30))
+		#expect(try JulianCalendar.dateFrom(year: 2000, ordinalDay: 275) == (2000, 10, 1))
+		#expect(try JulianCalendar.dateFrom(year: 2000, ordinalDay: 305) == (2000, 10, 31))
+		#expect(try JulianCalendar.dateFrom(year: 2000, ordinalDay: 306) == (2000, 11, 1))
+		#expect(try JulianCalendar.dateFrom(year: 2000, ordinalDay: 335) == (2000, 11, 30))
+		#expect(try JulianCalendar.dateFrom(year: 2000, ordinalDay: 336) == (2000, 12, 1))
+		#expect(try JulianCalendar.dateFrom(year: 2000, ordinalDay: 366) == (2000, 12, 31))
 	}
 
-	@Test func dayOfWeek() {
+	@Test func dayOfWeek() throws {
 		#expect(JulianCalendar.dayOfWeek(JulianCalendar.epoch) == 7)
 		#expect(JulianCalendar.dayOfWeek(-9) == 7)
 		#expect(JulianCalendar.dayOfWeek(-8) == 1)
@@ -179,7 +179,7 @@ import Testing
 		#expect(JulianCalendar.dayOfWeek(5) == 7)
 		#expect(JulianCalendar.dayOfWeek(6) == 1)
 
-		#expect(JulianCalendar.dayOfWeek(JulianCalendar.julianDayNumberFromDate((-10028, 3, 1))) == JulianCalendar.dayOfWeek(JulianCalendar.julianDayNumberFromDate((-10000, 3, 1))))
+		#expect(try JulianCalendar.dayOfWeek(JulianCalendar.julianDayNumberFromDate((-10028, 3, 1))) == JulianCalendar.dayOfWeek(JulianCalendar.julianDayNumberFromDate((-10000, 3, 1))))
 	}
 
 	@Test func easter() {
@@ -189,59 +189,59 @@ import Testing
 		#expect(JulianCalendar.easter(year: 1243) == (4, 12))
 	}
 
-	@Test func julianDayNumber() {
-		#expect(JulianCalendar.julianDayNumberFrom(year: -999999, month: 1, day: 1) == -363528576)
-		#expect(JulianCalendar.julianDayNumberFrom(year: -99999, month: 1, day: 1) == -34803576)
-		#expect(JulianCalendar.julianDayNumberFrom(year: -9999, month: 1, day: 1) == -1931076)
-		#expect(JulianCalendar.julianDayNumberFrom(year: 9999, month: 12, day: 31) == 5373557)
-		#expect(JulianCalendar.julianDayNumberFrom(year: 99999, month: 12, day: 31) == 38246057)
-		#expect(JulianCalendar.julianDayNumberFrom(year: 999999, month: 12, day: 31) == 366971057)
-		#expect(JulianCalendar.julianDayNumberFrom(year: -4713, month: 12, day: 31) == -1)
-		#expect(JulianCalendar.julianDayNumberFrom(year: -4712, month: 1, day: 1) == 0)
-		#expect(JulianCalendar.julianDayNumberFrom(year: -4712, month: 1, day: 2) == 1)
-		#expect(JulianCalendar.julianDayNumberFrom(year: 1582, month: 10, day: 4) == 2299160)
-		#expect(JulianCalendar.julianDayNumberFrom(year: 1582, month: 10, day: 15) == 2299171)
-		#expect(JulianCalendar.julianDayNumberFrom(year: 2000, month: 1, day: 1) == 2451558)
-		#expect(JulianCalendar.julianDayNumberFrom(year: -5000, month: 1, day: 1) == -105192)
-
-		#expect(JulianCalendar.dateFromJulianDayNumber(-363528576) == (-999999, 1, 1))
-		#expect(JulianCalendar.dateFromJulianDayNumber(-34803576) == (-99999, 1, 1))
-		#expect(JulianCalendar.dateFromJulianDayNumber(-1931076) == (-9999, 1, 1))
-		#expect(JulianCalendar.dateFromJulianDayNumber(5373557) == (9999, 12, 31))
-		#expect(JulianCalendar.dateFromJulianDayNumber(38246057) == (99999, 12, 31))
-		#expect(JulianCalendar.dateFromJulianDayNumber(366971057) == (999999, 12, 31))
-		#expect(JulianCalendar.dateFromJulianDayNumber(-1) == (-4713, 12, 31))
-		#expect(JulianCalendar.dateFromJulianDayNumber(0) == (-4712, 1, 1))
-		#expect(JulianCalendar.dateFromJulianDayNumber(1) == (-4712, 1, 2))
-		#expect(JulianCalendar.dateFromJulianDayNumber(2299160) == (1582, 10, 4))
-		#expect(JulianCalendar.dateFromJulianDayNumber(2299171) == (1582, 10, 15))
-		#expect(JulianCalendar.dateFromJulianDayNumber(2451558) == (2000, 1, 1))
-		#expect(JulianCalendar.dateFromJulianDayNumber(-105192) == (-5000, 1, 1))
+	@Test func julianDayNumber() throws {
+		#expect(try JulianCalendar.julianDayNumberFrom(year: -999999, month: 1, day: 1) == -363528576)
+		#expect(try JulianCalendar.julianDayNumberFrom(year: -99999, month: 1, day: 1) == -34803576)
+		#expect(try JulianCalendar.julianDayNumberFrom(year: -9999, month: 1, day: 1) == -1931076)
+		#expect(try JulianCalendar.julianDayNumberFrom(year: 9999, month: 12, day: 31) == 5373557)
+		#expect(try JulianCalendar.julianDayNumberFrom(year: 99999, month: 12, day: 31) == 38246057)
+		#expect(try JulianCalendar.julianDayNumberFrom(year: 999999, month: 12, day: 31) == 366971057)
+		#expect(try JulianCalendar.julianDayNumberFrom(year: -4713, month: 12, day: 31) == -1)
+		#expect(try JulianCalendar.julianDayNumberFrom(year: -4712, month: 1, day: 1) == 0)
+		#expect(try JulianCalendar.julianDayNumberFrom(year: -4712, month: 1, day: 2) == 1)
+		#expect(try JulianCalendar.julianDayNumberFrom(year: 1582, month: 10, day: 4) == 2299160)
+		#expect(try JulianCalendar.julianDayNumberFrom(year: 1582, month: 10, day: 15) == 2299171)
+		#expect(try JulianCalendar.julianDayNumberFrom(year: 2000, month: 1, day: 1) == 2451558)
+		#expect(try JulianCalendar.julianDayNumberFrom(year: -5000, month: 1, day: 1) == -105192)
+
+		#expect(try JulianCalendar.dateFromJulianDayNumber(-363528576) == (-999999, 1, 1))
+		#expect(try JulianCalendar.dateFromJulianDayNumber(-34803576) == (-99999, 1, 1))
+		#expect(try JulianCalendar.dateFromJulianDayNumber(-1931076) == (-9999, 1, 1))
+		#expect(try JulianCalendar.dateFromJulianDayNumber(5373557) == (9999, 12, 31))
+		#expect(try JulianCalendar.dateFromJulianDayNumber(38246057) == (99999, 12, 31))
+		#expect(try JulianCalendar.dateFromJulianDayNumber(366971057) == (999999, 12, 31))
+		#expect(try JulianCalendar.dateFromJulianDayNumber(-1) == (-4713, 12, 31))
+		#expect(try JulianCalendar.dateFromJulianDayNumber(0) == (-4712, 1, 1))
+		#expect(try JulianCalendar.dateFromJulianDayNumber(1) == (-4712, 1, 2))
+		#expect(try JulianCalendar.dateFromJulianDayNumber(2299160) == (1582, 10, 4))
+		#expect(try JulianCalendar.dateFromJulianDayNumber(2299171) == (1582, 10, 15))
+		#expect(try JulianCalendar.dateFromJulianDayNumber(2451558) == (2000, 1, 1))
+		#expect(try JulianCalendar.dateFromJulianDayNumber(-105192) == (-5000, 1, 1))
 	}
 
-	@Test func limits() {
-		#expect(JulianCalendar.julianDateFrom(year: -999999, month: 1, day: 1) == -363528576.5)
-		#expect(JulianCalendar.julianDateFrom(year: -99999, month: 1, day: 1) == -34803576.5)
-		#expect(JulianCalendar.julianDateFrom(year: -9999, month: 1, day: 1) == -1931076.5)
-		#expect(JulianCalendar.julianDateFrom(year: 9999, month: 12, day: 31) == 5373556.5)
-		#expect(JulianCalendar.julianDateFrom(year: 99999, month: 12, day: 31) == 38246056.5)
-		#expect(JulianCalendar.julianDateFrom(year: 999999, month: 12, day: 31) == 366971056.5)
-
-		#expect(JulianCalendar.dateAndTimeFromJulianDate(-363528576.5) == (-999999, 1, 1, 0, 0, 0))
-		#expect(JulianCalendar.dateAndTimeFromJulianDate(-34803576.5) == (-99999, 1, 1, 0, 0, 0))
-		#expect(JulianCalendar.dateAndTimeFromJulianDate(-1931076.5) == (-9999, 1, 1, 0, 0, 0))
-		#expect(JulianCalendar.dateAndTimeFromJulianDate(5373556.5) == (9999, 12, 31, 0, 0, 0))
-		#expect(JulianCalendar.dateAndTimeFromJulianDate(38246056.5) == (99999, 12, 31, 0, 0, 0))
-		#expect(JulianCalendar.dateAndTimeFromJulianDate(366971056.5) == (999999, 12, 31, 0, 0, 0))
+	@Test func limits() throws {
+		#expect(try JulianCalendar.julianDateFrom(year: -999999, month: 1, day: 1) == -363528576.5)
+		#expect(try JulianCalendar.julianDateFrom(year: -99999, month: 1, day: 1) == -34803576.5)
+		#expect(try JulianCalendar.julianDateFrom(year: -9999, month: 1, day: 1) == -1931076.5)
+		#expect(try JulianCalendar.julianDateFrom(year: 9999, month: 12, day: 31) == 5373556.5)
+		#expect(try JulianCalendar.julianDateFrom(year: 99999, month: 12, day: 31) == 38246056.5)
+		#expect(try JulianCalendar.julianDateFrom(year: 999999, month: 12, day: 31) == 366971056.5)
+
+		#expect(try JulianCalendar.dateAndTimeFromJulianDate(-363528576.5) == (-999999, 1, 1, 0, 0, 0))
+		#expect(try JulianCalendar.dateAndTimeFromJulianDate(-34803576.5) == (-99999, 1, 1, 0, 0, 0))
+		#expect(try JulianCalendar.dateAndTimeFromJulianDate(-1931076.5) == (-9999, 1, 1, 0, 0, 0))
+		#expect(try JulianCalendar.dateAndTimeFromJulianDate(5373556.5) == (9999, 12, 31, 0, 0, 0))
+		#expect(try JulianCalendar.dateAndTimeFromJulianDate(38246056.5) == (99999, 12, 31, 0, 0, 0))
+		#expect(try JulianCalendar.dateAndTimeFromJulianDate(366971056.5) == (999999, 12, 31, 0, 0, 0))
 	}
 
-	@Test func arithmeticLimits() {
-		let minDate = JulianCalendar.dateFromJulianDayNumber(.min)
-		let minJ = JulianCalendar.julianDayNumberFromDate(minDate)
+	@Test func arithmeticLimits() throws {
+		let minDate = try JulianCalendar.dateFromJulianDayNumber(.min)
+		let minJ = try JulianCalendar.julianDayNumberFromDate(minDate)
 		#expect(minJ == .min)
 
-		let maxDate = JulianCalendar.dateFromJulianDayNumber(.max)
-		let maxJ = JulianCalendar.julianDayNumberFromDate(maxDate)
+		let maxDate = try JulianCalendar.dateFromJulianDayNumber(.max)
+		let maxJ = try JulianCalendar.julianDayNumberFromDate(maxDate)
 		#expect(maxJ == .max)
 	}
 }
diff --git a/Tests/JulianDayNumberTests/KhwarizmianCalendarTests.swift b/Tests/JulianDayNumberTests/KhwarizmianCalendarTests.swift
index 80d733a..900a42f 100644
--- a/Tests/JulianDayNumberTests/KhwarizmianCalendarTests.swift
+++ b/Tests/JulianDayNumberTests/KhwarizmianCalendarTests.swift
@@ -8,9 +8,9 @@ import Testing
 @testable import JulianDayNumber
 
 @Suite struct KhwarizmianCalendarTests {
-	@Test func epoch() {
-		#expect(KhwarizmianCalendar.julianDayNumberFrom(year: 1, month: 1, day: 1) == KhwarizmianCalendar.epoch)
-		#expect(KhwarizmianCalendar.dateFromJulianDayNumber(KhwarizmianCalendar.epoch) == (1, 1, 1))
+	@Test func epoch() throws {
+		#expect(try KhwarizmianCalendar.julianDayNumberFrom(year: 1, month: 1, day: 1) == KhwarizmianCalendar.epoch)
+		#expect(try KhwarizmianCalendar.dateFromJulianDayNumber(KhwarizmianCalendar.epoch) == (1, 1, 1))
 	}
 
 	@Test func monthLength() {
@@ -24,34 +24,34 @@ import Testing
 		#expect(KhwarizmianCalendar.numberOfDaysInYear == 365)
 	}
 
-	@Test func julianDayNumber() {
-		#expect(KhwarizmianCalendar.julianDayNumberFrom(year: 1, month: 1, day: 1) == 1952068)
-		#expect(KhwarizmianCalendar.dateFromJulianDayNumber(1952068) == (1, 1, 1))
+	@Test func julianDayNumber() throws {
+		#expect(try KhwarizmianCalendar.julianDayNumberFrom(year: 1, month: 1, day: 1) == 1952068)
+		#expect(try KhwarizmianCalendar.dateFromJulianDayNumber(1952068) == (1, 1, 1))
 	}
 
-	@Test func limits() {
-		#expect(KhwarizmianCalendar.julianDateFrom(year: -999999, month: 1, day: 1) == -363047932.5)
-		#expect(KhwarizmianCalendar.julianDateFrom(year: -99999, month: 1, day: 1) == -34547932.5)
-		#expect(KhwarizmianCalendar.julianDateFrom(year: -9999, month: 1, day: 1) == -1697932.5)
-		#expect(KhwarizmianCalendar.julianDateFrom(year: 9999, month: 13, day: 5) == 5601701.5)
-		#expect(KhwarizmianCalendar.julianDateFrom(year: 99999, month: 13, day: 5) == 38451701.5)
-		#expect(KhwarizmianCalendar.julianDateFrom(year: 999999, month: 13, day: 5) == 366951701.5)
-
-		#expect(KhwarizmianCalendar.dateAndTimeFromJulianDate(-363047932.5) == (-999999, 1, 1, 0, 0, 0))
-		#expect(KhwarizmianCalendar.dateAndTimeFromJulianDate(-34547932.5) == (-99999, 1, 1, 0, 0, 0))
-		#expect(KhwarizmianCalendar.dateAndTimeFromJulianDate(-1697932.5) == (-9999, 1, 1, 0, 0, 0))
-		#expect(KhwarizmianCalendar.dateAndTimeFromJulianDate(5601701.5) == (9999, 13, 5, 0, 0, 0))
-		#expect(KhwarizmianCalendar.dateAndTimeFromJulianDate(38451701.5) == (99999, 13, 5, 0, 0, 0))
-		#expect(KhwarizmianCalendar.dateAndTimeFromJulianDate(366951701.5) == (999999, 13, 5, 0, 0, 0))
+	@Test func limits() throws {
+		#expect(try KhwarizmianCalendar.julianDateFrom(year: -999999, month: 1, day: 1) == -363047932.5)
+		#expect(try KhwarizmianCalendar.julianDateFrom(year: -99999, month: 1, day: 1) == -34547932.5)
+		#expect(try KhwarizmianCalendar.julianDateFrom(year: -9999, month: 1, day: 1) == -1697932.5)
+		#expect(try KhwarizmianCalendar.julianDateFrom(year: 9999, month: 13, day: 5) == 5601701.5)
+		#expect(try KhwarizmianCalendar.julianDateFrom(year: 99999, month: 13, day: 5) == 38451701.5)
+		#expect(try KhwarizmianCalendar.julianDateFrom(year: 999999, month: 13, day: 5) == 366951701.5)
+
+		#expect(try KhwarizmianCalendar.dateAndTimeFromJulianDate(-363047932.5) == (-999999, 1, 1, 0, 0, 0))
+		#expect(try KhwarizmianCalendar.dateAndTimeFromJulianDate(-34547932.5) == (-99999, 1, 1, 0, 0, 0))
+		#expect(try KhwarizmianCalendar.dateAndTimeFromJulianDate(-1697932.5) == (-9999, 1, 1, 0, 0, 0))
+		#expect(try KhwarizmianCalendar.dateAndTimeFromJulianDate(5601701.5) == (9999, 13, 5, 0, 0, 0))
+		#expect(try KhwarizmianCalendar.dateAndTimeFromJulianDate(38451701.5) == (99999, 13, 5, 0, 0, 0))
+		#expect(try KhwarizmianCalendar.dateAndTimeFromJulianDate(366951701.5) == (999999, 13, 5, 0, 0, 0))
 	}
 
-	@Test func arithmeticLimits() {
-		let minDate = KhwarizmianCalendar.dateFromJulianDayNumber(.min + 341)
-		let minJ = KhwarizmianCalendar.julianDayNumberFromDate(minDate)
+	@Test func arithmeticLimits() throws {
+		let minDate = try KhwarizmianCalendar.dateFromJulianDayNumber(.min + 341)
+		let minJ = try KhwarizmianCalendar.julianDayNumberFromDate(minDate)
 		#expect(minJ == .min + 341)
 
-		let maxDate = KhwarizmianCalendar.dateFromJulianDayNumber(.max)
-		let maxJ = KhwarizmianCalendar.julianDayNumberFromDate(maxDate)
+		let maxDate = try KhwarizmianCalendar.dateFromJulianDayNumber(.max)
+		let maxJ = try KhwarizmianCalendar.julianDayNumberFromDate(maxDate)
 		#expect(maxJ == .max)
 	}
 }
diff --git a/Tests/JulianDayNumberTests/MacedonianCalendarTests.swift b/Tests/JulianDayNumberTests/MacedonianCalendarTests.swift
index 12b87d4..fb42d40 100644
--- a/Tests/JulianDayNumberTests/MacedonianCalendarTests.swift
+++ b/Tests/JulianDayNumberTests/MacedonianCalendarTests.swift
@@ -8,17 +8,17 @@ import Testing
 @testable import JulianDayNumber
 
 @Suite struct MacedonianCalendarTests {
-	@Test func epoch() {
-		#expect(MacedonianCalendar.julianDayNumberFrom(year: 1, month: 1, day: 1) == MacedonianCalendar.epoch)
-		#expect(MacedonianCalendar.dateFromJulianDayNumber(MacedonianCalendar.epoch) == (1, 1, 1))
+	@Test func epoch() throws {
+		#expect(try MacedonianCalendar.julianDayNumberFrom(year: 1, month: 1, day: 1) == MacedonianCalendar.epoch)
+		#expect(try MacedonianCalendar.dateFromJulianDayNumber(MacedonianCalendar.epoch) == (1, 1, 1))
 	}
 
-	@Test func julianDayNumber() {
-		#expect(MacedonianCalendar.julianDayNumberFrom(year: 1, month: 1, day: 1) == 1607709)
-		#expect(MacedonianCalendar.dateFromJulianDayNumber(1607709) == (1, 1, 1))
+	@Test func julianDayNumber() throws {
+		#expect(try MacedonianCalendar.julianDayNumberFrom(year: 1, month: 1, day: 1) == 1607709)
+		#expect(try MacedonianCalendar.dateFromJulianDayNumber(1607709) == (1, 1, 1))
 	}
 
-	@Test func leapYear() {
+	@Test func leapYear() throws {
 		#expect(!MacedonianCalendar.isLeapYear(1))
 		#expect(MacedonianCalendar.isLeapYear(3))
 		#expect(MacedonianCalendar.isLeapYear(7))
@@ -29,8 +29,8 @@ import Testing
 
 		for y in -500...500 {
 			let isLeap = MacedonianCalendar.isLeapYear(y)
-			let j = MacedonianCalendar.julianDayNumberFrom(year: y, month: 6, day: isLeap ? 29 : 28)
-			let d = MacedonianCalendar.dateFromJulianDayNumber(j)
+			let j = try MacedonianCalendar.julianDayNumberFrom(year: y, month: 6, day: isLeap ? 29 : 28)
+			let d = try MacedonianCalendar.dateFromJulianDayNumber(j)
 			#expect(d.month == 6)
 			#expect(d.day == (isLeap ? 29 : 28))
 		}
@@ -65,29 +65,29 @@ import Testing
 		#expect(MacedonianCalendar.numberOfDays(inYear: 1739) == 366)
 	}
 
-	@Test func limits() {
-		#expect(MacedonianCalendar.julianDateFrom(year: -999999, month: 1, day: 1) == -363642291.5)
-		#expect(MacedonianCalendar.julianDateFrom(year: -99999, month: 1, day: 1) == -34917291.5)
-		#expect(MacedonianCalendar.julianDateFrom(year: -9999, month: 1, day: 1) == -2044791.5)
-		#expect(MacedonianCalendar.julianDateFrom(year: 9999, month: 12, day: 31) == 5259842.5)
-		#expect(MacedonianCalendar.julianDateFrom(year: 99999, month: 12, day: 31) == 38132342.5)
-		#expect(MacedonianCalendar.julianDateFrom(year: 999999, month: 12, day: 31) == 366857342.5)
+	@Test func limits() throws {
+		#expect(try MacedonianCalendar.julianDateFrom(year: -999999, month: 1, day: 1) == -363642291.5)
+		#expect(try MacedonianCalendar.julianDateFrom(year: -99999, month: 1, day: 1) == -34917291.5)
+		#expect(try MacedonianCalendar.julianDateFrom(year: -9999, month: 1, day: 1) == -2044791.5)
+		#expect(try MacedonianCalendar.julianDateFrom(year: 9999, month: 12, day: 31) == 5259842.5)
+		#expect(try MacedonianCalendar.julianDateFrom(year: 99999, month: 12, day: 31) == 38132342.5)
+		#expect(try MacedonianCalendar.julianDateFrom(year: 999999, month: 12, day: 31) == 366857342.5)
 
-		#expect(MacedonianCalendar.dateAndTimeFromJulianDate(-363642291.5) == (-999999, 1, 1, 0, 0, 0))
-		#expect(MacedonianCalendar.dateAndTimeFromJulianDate(-34917291.5) == (-99999, 1, 1, 0, 0, 0))
-		#expect(MacedonianCalendar.dateAndTimeFromJulianDate(-2044791.5) == (-9999, 1, 1, 0, 0, 0))
-		#expect(MacedonianCalendar.dateAndTimeFromJulianDate(5259842.5) == (9999, 12, 31, 0, 0, 0))
-		#expect(MacedonianCalendar.dateAndTimeFromJulianDate(38132342.5) == (99999, 12, 31, 0, 0, 0))
-		#expect(MacedonianCalendar.dateAndTimeFromJulianDate(366857342.5) == (999999, 12, 31, 0, 0, 0))
+		#expect(try MacedonianCalendar.dateAndTimeFromJulianDate(-363642291.5) == (-999999, 1, 1, 0, 0, 0))
+		#expect(try MacedonianCalendar.dateAndTimeFromJulianDate(-34917291.5) == (-99999, 1, 1, 0, 0, 0))
+		#expect(try MacedonianCalendar.dateAndTimeFromJulianDate(-2044791.5) == (-9999, 1, 1, 0, 0, 0))
+		#expect(try MacedonianCalendar.dateAndTimeFromJulianDate(5259842.5) == (9999, 12, 31, 0, 0, 0))
+		#expect(try MacedonianCalendar.dateAndTimeFromJulianDate(38132342.5) == (99999, 12, 31, 0, 0, 0))
+		#expect(try MacedonianCalendar.dateAndTimeFromJulianDate(366857342.5) == (999999, 12, 31, 0, 0, 0))
 	}
 
-	@Test func arithmeticLimits() {
-		let minDate = MacedonianCalendar.dateFromJulianDayNumber(.min)
-		let minJ = MacedonianCalendar.julianDayNumberFromDate(minDate)
+	@Test func arithmeticLimits() throws {
+		let minDate = try MacedonianCalendar.dateFromJulianDayNumber(.min)
+		let minJ = try MacedonianCalendar.julianDayNumberFromDate(minDate)
 		#expect(minJ == .min)
 
-		let maxDate = MacedonianCalendar.dateFromJulianDayNumber(.max)
-		let maxJ = MacedonianCalendar.julianDayNumberFromDate(maxDate)
+		let maxDate = try MacedonianCalendar.dateFromJulianDayNumber(.max)
+		let maxJ = try MacedonianCalendar.julianDayNumberFromDate(maxDate)
 		#expect(maxJ == .max)
 	}
 }
diff --git a/Tests/JulianDayNumberTests/MayaCalendarTests.swift b/Tests/JulianDayNumberTests/MayaCalendarTests.swift
index c2407a3..2b0a944 100644
--- a/Tests/JulianDayNumberTests/MayaCalendarTests.swift
+++ b/Tests/JulianDayNumberTests/MayaCalendarTests.swift
@@ -8,9 +8,9 @@ import Testing
 @testable import JulianDayNumber
 
 @Suite struct MayaCalendarTests {
-	@Test func epoch() {
-		#expect(MayaCalendar.julianDayNumberFromLongCount(baktun: 0, katun: 0, tun: 0, uinal: 0, kin: 0) == MayaCalendar.epoch)
-		#expect(MayaCalendar.dateFromJulianDayNumber(MayaCalendar.epoch) == (0, 0, 0, 0, 0))
+	@Test func epoch() throws {
+		#expect(try MayaCalendar.julianDayNumberFromLongCount(baktun: 0, katun: 0, tun: 0, uinal: 0, kin: 0) == MayaCalendar.epoch)
+		#expect(try MayaCalendar.dateFromJulianDayNumber(MayaCalendar.epoch) == (0, 0, 0, 0, 0))
 	}
 
 	@Test func dateValidation() {
@@ -25,28 +25,28 @@ import Testing
 		#expect(MayaCalendar.isValidLongCount(baktun: -1, katun: 0, tun: 0, uinal: 0, kin: 0))
 	}
 
-	@Test func longCount() {
-		#expect(MayaCalendar.longCountFromJulianDayNumber(584286) == (0, 0, 0, 0, 3))
-		#expect(MayaCalendar.longCountFromJulianDayNumber(584285) == (0, 0, 0, 0, 2))
-		#expect(MayaCalendar.longCountFromJulianDayNumber(584284) == (0, 0, 0, 0, 1))
-		#expect(MayaCalendar.longCountFromJulianDayNumber(584283) == (0, 0, 0, 0, 0))
-		#expect(MayaCalendar.longCountFromJulianDayNumber(584282) == (-1, 19, 19, 17, 19))
-		#expect(MayaCalendar.longCountFromJulianDayNumber(584281) == (-1, 19, 19, 17, 18))
-		#expect(MayaCalendar.longCountFromJulianDayNumber(584280) == (-1, 19, 19, 17, 17))
+	@Test func longCount() throws {
+		#expect(try MayaCalendar.longCountFromJulianDayNumber(584286) == (0, 0, 0, 0, 3))
+		#expect(try MayaCalendar.longCountFromJulianDayNumber(584285) == (0, 0, 0, 0, 2))
+		#expect(try MayaCalendar.longCountFromJulianDayNumber(584284) == (0, 0, 0, 0, 1))
+		#expect(try MayaCalendar.longCountFromJulianDayNumber(584283) == (0, 0, 0, 0, 0))
+		#expect(try MayaCalendar.longCountFromJulianDayNumber(584282) == (-1, 19, 19, 17, 19))
+		#expect(try MayaCalendar.longCountFromJulianDayNumber(584281) == (-1, 19, 19, 17, 18))
+		#expect(try MayaCalendar.longCountFromJulianDayNumber(584280) == (-1, 19, 19, 17, 17))
 
-		#expect(MayaCalendar.longCountFromJulianDayNumber(300) == (-5, 18, 17, 14, 17))
-		#expect(MayaCalendar.longCountFromJulianDayNumber(3) == (-5, 18, 17, 0, 0))
-		#expect(MayaCalendar.longCountFromJulianDayNumber(2) == (-5, 18, 16, 17, 19))
-		#expect(MayaCalendar.longCountFromJulianDayNumber(1) == (-5, 18, 16, 17, 18))
-		#expect(MayaCalendar.longCountFromJulianDayNumber(0) == (-5, 18, 16, 17, 17))
-		#expect(MayaCalendar.longCountFromJulianDayNumber(-1) == (-5, 18, 16, 17, 16))
-		#expect(MayaCalendar.longCountFromJulianDayNumber(-2) == (-5, 18, 16, 17, 15))
-		#expect(MayaCalendar.longCountFromJulianDayNumber(-3) == (-5, 18, 16, 17, 14))
-		#expect(MayaCalendar.longCountFromJulianDayNumber(-300) == (-5, 18, 16, 2, 17))
+		#expect(try MayaCalendar.longCountFromJulianDayNumber(300) == (-5, 18, 17, 14, 17))
+		#expect(try MayaCalendar.longCountFromJulianDayNumber(3) == (-5, 18, 17, 0, 0))
+		#expect(try MayaCalendar.longCountFromJulianDayNumber(2) == (-5, 18, 16, 17, 19))
+		#expect(try MayaCalendar.longCountFromJulianDayNumber(1) == (-5, 18, 16, 17, 18))
+		#expect(try MayaCalendar.longCountFromJulianDayNumber(0) == (-5, 18, 16, 17, 17))
+		#expect(try MayaCalendar.longCountFromJulianDayNumber(-1) == (-5, 18, 16, 17, 16))
+		#expect(try MayaCalendar.longCountFromJulianDayNumber(-2) == (-5, 18, 16, 17, 15))
+		#expect(try MayaCalendar.longCountFromJulianDayNumber(-3) == (-5, 18, 16, 17, 14))
+		#expect(try MayaCalendar.longCountFromJulianDayNumber(-300) == (-5, 18, 16, 2, 17))
 
-		#expect(MayaCalendar.julianDayNumberFromLongCount(baktun: 0, katun: 0, tun: 0, uinal: 0, kin: 0) == 584283)
+		#expect(try MayaCalendar.julianDayNumberFromLongCount(baktun: 0, katun: 0, tun: 0, uinal: 0, kin: 0) == 584283)
 
-		#expect(MayaCalendar.julianDayNumberFromLongCount(baktun: 0, katun: 0, tun: 0, uinal: -1, kin: 19) == MayaCalendar.julianDayNumberFromLongCount(baktun: 0, katun: 0, tun: -1, uinal: 17, kin: 19))
+		#expect(try MayaCalendar.julianDayNumberFromLongCount(baktun: 0, katun: 0, tun: 0, uinal: -1, kin: 19) == MayaCalendar.julianDayNumberFromLongCount(baktun: 0, katun: 0, tun: -1, uinal: 17, kin: 19))
 	}
 
 	@Test func calendarRound() {
@@ -65,29 +65,29 @@ import Testing
 		#expect(MayaCalendar.lordOfTheNightFrom(uinal: 17, kin: 19) == 8)
 	}
 
-	@Test func limits() {
-		#expect(MayaCalendar.julianDayNumberFromLongCount(baktun: -2535, katun: 5, tun: 12, uinal: 2, kin: 5) == -364415352)
-		#expect(MayaCalendar.julianDayNumberFromLongCount(baktun: -254, katun: 10, tun: 12, uinal: 2, kin: 5) == -35915352)
-		#expect(MayaCalendar.julianDayNumberFromLongCount(baktun: 0, katun: 0, tun: 0, uinal: 0, kin: -3649635) == -3065352)
-		#expect(MayaCalendar.julianDayNumberFromLongCount(baktun: 0, katun: 0, tun: 0, uinal: 0, kin: 3649635) == 4233918)
-		#expect(MayaCalendar.julianDayNumberFromLongCount(baktun: 253, katun: 9, tun: 7, uinal: 15, kin: 15) == 37083918)
-		#expect(MayaCalendar.julianDayNumberFromLongCount(baktun: 2534, katun: 14, tun: 7, uinal: 15, kin: 15) == 365583918)
+	@Test func limits() throws {
+		#expect(try MayaCalendar.julianDayNumberFromLongCount(baktun: -2535, katun: 5, tun: 12, uinal: 2, kin: 5) == -364415352)
+		#expect(try MayaCalendar.julianDayNumberFromLongCount(baktun: -254, katun: 10, tun: 12, uinal: 2, kin: 5) == -35915352)
+		#expect(try MayaCalendar.julianDayNumberFromLongCount(baktun: 0, katun: 0, tun: 0, uinal: 0, kin: -3649635) == -3065352)
+		#expect(try MayaCalendar.julianDayNumberFromLongCount(baktun: 0, katun: 0, tun: 0, uinal: 0, kin: 3649635) == 4233918)
+		#expect(try MayaCalendar.julianDayNumberFromLongCount(baktun: 253, katun: 9, tun: 7, uinal: 15, kin: 15) == 37083918)
+		#expect(try MayaCalendar.julianDayNumberFromLongCount(baktun: 2534, katun: 14, tun: 7, uinal: 15, kin: 15) == 365583918)
 
-		#expect(MayaCalendar.longCountFromJulianDayNumber(-364415352) == (-2535, 5, 12, 2, 5))
-		#expect(MayaCalendar.longCountFromJulianDayNumber(-35915352) == (-254, 10, 12, 2, 5))
-		#expect(MayaCalendar.longCountFromJulianDayNumber(-3065352) == (-26, 13, 2, 2, 5))
-		#expect(MayaCalendar.longCountFromJulianDayNumber(4233918) == (25, 6, 17, 15, 15))
-		#expect(MayaCalendar.longCountFromJulianDayNumber(37083918) == (253, 9, 7, 15, 15))
-		#expect(MayaCalendar.longCountFromJulianDayNumber(365583918) == (2534, 14, 7, 15, 15))
+		#expect(try MayaCalendar.longCountFromJulianDayNumber(-364415352) == (-2535, 5, 12, 2, 5))
+		#expect(try MayaCalendar.longCountFromJulianDayNumber(-35915352) == (-254, 10, 12, 2, 5))
+		#expect(try MayaCalendar.longCountFromJulianDayNumber(-3065352) == (-26, 13, 2, 2, 5))
+		#expect(try MayaCalendar.longCountFromJulianDayNumber(4233918) == (25, 6, 17, 15, 15))
+		#expect(try MayaCalendar.longCountFromJulianDayNumber(37083918) == (253, 9, 7, 15, 15))
+		#expect(try MayaCalendar.longCountFromJulianDayNumber(365583918) == (2534, 14, 7, 15, 15))
 	}
 
-	@Test func arithmeticLimits() {
-		let minLC = MayaCalendar.dateFromJulianDayNumber(.min)
-		let minJ = MayaCalendar.julianDayNumberFromDate(minLC)
+	@Test func arithmeticLimits() throws {
+		let minLC = try MayaCalendar.dateFromJulianDayNumber(.min)
+		let minJ = try MayaCalendar.julianDayNumberFromDate(minLC)
 		#expect(minJ == .min)
 
-		let maxLC = MayaCalendar.dateFromJulianDayNumber(.max)
-		let maxJ = MayaCalendar.julianDayNumberFromDate(maxLC)
+		let maxLC = try MayaCalendar.dateFromJulianDayNumber(.max)
+		let maxJ = try MayaCalendar.julianDayNumberFromDate(maxLC)
 		#expect(maxJ == .max)
 	}
 }
diff --git a/Tests/JulianDayNumberTests/PersianCalendarTests.swift b/Tests/JulianDayNumberTests/PersianCalendarTests.swift
index eb3baaf..30038ac 100644
--- a/Tests/JulianDayNumberTests/PersianCalendarTests.swift
+++ b/Tests/JulianDayNumberTests/PersianCalendarTests.swift
@@ -8,9 +8,9 @@ import Testing
 @testable import JulianDayNumber
 
 @Suite struct PersianCalendarTests {
-	@Test func epoch() {
-		#expect(PersianCalendar.julianDayNumberFrom(year: 1, month: 1, day: 1) == PersianCalendar.epoch)
-		#expect(PersianCalendar.dateFromJulianDayNumber(PersianCalendar.epoch) == (1, 1, 1))
+	@Test func epoch() throws {
+		#expect(try PersianCalendar.julianDayNumberFrom(year: 1, month: 1, day: 1) == PersianCalendar.epoch)
+		#expect(try PersianCalendar.dateFromJulianDayNumber(PersianCalendar.epoch) == (1, 1, 1))
 	}
 
 	@Test func monthLength() {
@@ -27,34 +27,34 @@ import Testing
 		#expect(PersianCalendar.numberOfDaysInYear == 365)
 	}
 
-	@Test func julianDayNumber() {
-		#expect(PersianCalendar.julianDayNumberFrom(year: 1, month: 1, day: 1) == 1952063)
-		#expect(PersianCalendar.dateFromJulianDayNumber(1952063) == (1, 1, 1))
+	@Test func julianDayNumber() throws {
+		#expect(try PersianCalendar.julianDayNumberFrom(year: 1, month: 1, day: 1) == 1952063)
+		#expect(try PersianCalendar.dateFromJulianDayNumber(1952063) == (1, 1, 1))
 	}
 
-	@Test func limits() {
-		#expect(PersianCalendar.julianDateFrom(year: -999999, month: 1, day: 1) == -363047937.5)
-		#expect(PersianCalendar.julianDateFrom(year: -99999, month: 1, day: 1) == -34547937.5)
-		#expect(PersianCalendar.julianDateFrom(year: -9999, month: 1, day: 1) == -1697937.5)
-		#expect(PersianCalendar.julianDateFrom(year: 9999, month: 13, day: 30) == 5601696.5)
-		#expect(PersianCalendar.julianDateFrom(year: 99999, month: 13, day: 30) == 38451696.5)
-		#expect(PersianCalendar.julianDateFrom(year: 999999, month: 13, day: 30) == 366951696.5)
-
-		#expect(PersianCalendar.dateAndTimeFromJulianDate(-363047937.5) == (-999999, 1, 1, 0, 0, 0))
-		#expect(PersianCalendar.dateAndTimeFromJulianDate(-34547937.5) == (-99999, 1, 1, 0, 0, 0))
-		#expect(PersianCalendar.dateAndTimeFromJulianDate(-1697937.5) == (-9999, 1, 1, 0, 0, 0))
-		#expect(PersianCalendar.dateAndTimeFromJulianDate(5601696.5) == (9999, 13, 30, 0, 0, 0))
-		#expect(PersianCalendar.dateAndTimeFromJulianDate(38451696.5) == (99999, 13, 30, 0, 0, 0))
-		#expect(PersianCalendar.dateAndTimeFromJulianDate(366951696.5) == (999999, 13, 30, 0, 0, 0))
+	@Test func limits() throws {
+		#expect(try PersianCalendar.julianDateFrom(year: -999999, month: 1, day: 1) == -363047937.5)
+		#expect(try PersianCalendar.julianDateFrom(year: -99999, month: 1, day: 1) == -34547937.5)
+		#expect(try PersianCalendar.julianDateFrom(year: -9999, month: 1, day: 1) == -1697937.5)
+		#expect(try PersianCalendar.julianDateFrom(year: 9999, month: 13, day: 30) == 5601696.5)
+		#expect(try PersianCalendar.julianDateFrom(year: 99999, month: 13, day: 30) == 38451696.5)
+		#expect(try PersianCalendar.julianDateFrom(year: 999999, month: 13, day: 30) == 366951696.5)
+
+		#expect(try PersianCalendar.dateAndTimeFromJulianDate(-363047937.5) == (-999999, 1, 1, 0, 0, 0))
+		#expect(try PersianCalendar.dateAndTimeFromJulianDate(-34547937.5) == (-99999, 1, 1, 0, 0, 0))
+		#expect(try PersianCalendar.dateAndTimeFromJulianDate(-1697937.5) == (-9999, 1, 1, 0, 0, 0))
+		#expect(try PersianCalendar.dateAndTimeFromJulianDate(5601696.5) == (9999, 13, 30, 0, 0, 0))
+		#expect(try PersianCalendar.dateAndTimeFromJulianDate(38451696.5) == (99999, 13, 30, 0, 0, 0))
+		#expect(try PersianCalendar.dateAndTimeFromJulianDate(366951696.5) == (999999, 13, 30, 0, 0, 0))
 	}
 
-	@Test func arithmeticLimits() {
-		let minDate = PersianCalendar.dateFromJulianDayNumber(.min + 336)
-		let minJ = PersianCalendar.julianDayNumberFromDate(minDate)
+	@Test func arithmeticLimits() throws {
+		let minDate = try PersianCalendar.dateFromJulianDayNumber(.min + 336)
+		let minJ = try PersianCalendar.julianDayNumberFromDate(minDate)
 		#expect(minJ == .min + 336)
 
-		let maxDate = PersianCalendar.dateFromJulianDayNumber(.max)
-		let maxJ = PersianCalendar.julianDayNumberFromDate(maxDate)
+		let maxDate = try PersianCalendar.dateFromJulianDayNumber(.max)
+		let maxJ = try PersianCalendar.julianDayNumberFromDate(maxDate)
 		#expect(maxJ == .max)
 	}
 }
diff --git a/Tests/JulianDayNumberTests/SakaCalendarTests.swift b/Tests/JulianDayNumberTests/SakaCalendarTests.swift
index 5224635..b770b75 100644
--- a/Tests/JulianDayNumberTests/SakaCalendarTests.swift
+++ b/Tests/JulianDayNumberTests/SakaCalendarTests.swift
@@ -8,9 +8,9 @@ import Testing
 @testable import JulianDayNumber
 
 @Suite struct SakaCalendarTests {
-	@Test func epoch() {
-		#expect(SakaCalendar.julianDayNumberFrom(year: 1, month: 1, day: 1) == SakaCalendar.epoch)
-		#expect(SakaCalendar.dateFromJulianDayNumber(SakaCalendar.epoch) == (1, 1, 1))
+	@Test func epoch() throws {
+		#expect(try SakaCalendar.julianDayNumberFrom(year: 1, month: 1, day: 1) == SakaCalendar.epoch)
+		#expect(try SakaCalendar.dateFromJulianDayNumber(SakaCalendar.epoch) == (1, 1, 1))
 	}
 
 	@Test func dateValidation() {
@@ -19,7 +19,7 @@ import Testing
 		#expect(SakaCalendar.isValid(year: 2, month: 1, day: 31))
 	}
 
-	@Test func leapYear() {
+	@Test func leapYear() throws {
 		#expect(SakaCalendar.isLeapYear(78))
 		#expect(!SakaCalendar.isLeapYear(4))
 		#expect(!SakaCalendar.isLeapYear(100))
@@ -31,8 +31,8 @@ import Testing
 
 		for y in -500...500 {
 			let isLeap = SakaCalendar.isLeapYear(y)
-			let j = SakaCalendar.julianDayNumberFrom(year: y, month: 1, day: isLeap ? 31 : 30)
-			let d = SakaCalendar.dateFromJulianDayNumber(j)
+			let j = try SakaCalendar.julianDayNumberFrom(year: y, month: 1, day: isLeap ? 31 : 30)
+			let d = try SakaCalendar.dateFromJulianDayNumber(j)
 			#expect(d.month == 1)
 			#expect(d.day == (isLeap ? 31 : 30))
 		}
@@ -65,33 +65,33 @@ import Testing
 		#expect(SakaCalendar.numberOfDays(inYear: 1522) == 366)
 	}
 
-	@Test func julianDayNumber() {
-		#expect(SakaCalendar.julianDayNumberFrom(year: 1, month: 1, day: 1) == 1749995)
+	@Test func julianDayNumber() throws {
+		#expect(try SakaCalendar.julianDayNumberFrom(year: 1, month: 1, day: 1) == 1749995)
 	}
 
-	@Test func limits() {
-		#expect(SakaCalendar.julianDateFrom(year: -999999, month: 1, day: 1) == -363492505.5)
-		#expect(SakaCalendar.julianDateFrom(year: -99999, month: 1, day: 1) == -34774255.5)
-		#expect(SakaCalendar.julianDateFrom(year: -9999, month: 1, day: 1) == -1902430.5)
-		#expect(SakaCalendar.julianDateFrom(year: 9999, month: 12, day: 30) == 5402053.5)
-		#expect(SakaCalendar.julianDateFrom(year: 99999, month: 12, day: 30) == 38273878.5)
-		#expect(SakaCalendar.julianDateFrom(year: 999999, month: 12, day: 30) == 366992128.5)
+	@Test func limits() throws {
+		#expect(try SakaCalendar.julianDateFrom(year: -999999, month: 1, day: 1) == -363492505.5)
+		#expect(try SakaCalendar.julianDateFrom(year: -99999, month: 1, day: 1) == -34774255.5)
+		#expect(try SakaCalendar.julianDateFrom(year: -9999, month: 1, day: 1) == -1902430.5)
+		#expect(try SakaCalendar.julianDateFrom(year: 9999, month: 12, day: 30) == 5402053.5)
+		#expect(try SakaCalendar.julianDateFrom(year: 99999, month: 12, day: 30) == 38273878.5)
+		#expect(try SakaCalendar.julianDateFrom(year: 999999, month: 12, day: 30) == 366992128.5)
 
-		#expect(SakaCalendar.dateAndTimeFromJulianDate(-363492505.5) == (-999999, 1, 1, 0, 0, 0))
-		#expect(SakaCalendar.dateAndTimeFromJulianDate(-34774255.5) == (-99999, 1, 1, 0, 0, 0))
-		#expect(SakaCalendar.dateAndTimeFromJulianDate(-1902430.5) == (-9999, 1, 1, 0, 0, 0))
-		#expect(SakaCalendar.dateAndTimeFromJulianDate(5402053.5) == (9999, 12, 30, 0, 0, 0))
-		#expect(SakaCalendar.dateAndTimeFromJulianDate(38273878.5) == (99999, 12, 30, 0, 0, 0))
-		#expect(SakaCalendar.dateAndTimeFromJulianDate(366992128.5) == (999999, 12, 30, 0, 0, 0))
+		#expect(try SakaCalendar.dateAndTimeFromJulianDate(-363492505.5) == (-999999, 1, 1, 0, 0, 0))
+		#expect(try SakaCalendar.dateAndTimeFromJulianDate(-34774255.5) == (-99999, 1, 1, 0, 0, 0))
+		#expect(try SakaCalendar.dateAndTimeFromJulianDate(-1902430.5) == (-9999, 1, 1, 0, 0, 0))
+		#expect(try SakaCalendar.dateAndTimeFromJulianDate(5402053.5) == (9999, 12, 30, 0, 0, 0))
+		#expect(try SakaCalendar.dateAndTimeFromJulianDate(38273878.5) == (99999, 12, 30, 0, 0, 0))
+		#expect(try SakaCalendar.dateAndTimeFromJulianDate(366992128.5) == (999999, 12, 30, 0, 0, 0))
 	}
 
-	@Test func arithmeticLimits() {
-		let minDate = SakaCalendar.dateFromJulianDayNumber(.min)
-		let minJ = SakaCalendar.julianDayNumberFromDate(minDate)
+	@Test func arithmeticLimits() throws {
+		let minDate = try SakaCalendar.dateFromJulianDayNumber(.min)
+		let minJ = try SakaCalendar.julianDayNumberFromDate(minDate)
 		#expect(minJ == .min)
 
-		let maxDate = SakaCalendar.dateFromJulianDayNumber(.max)
-		let maxJ = SakaCalendar.julianDayNumberFromDate(maxDate)
+		let maxDate = try SakaCalendar.dateFromJulianDayNumber(.max)
+		let maxJ = try SakaCalendar.julianDayNumberFromDate(maxDate)
 		#expect(maxJ == .max)
 	}
 }
diff --git a/Tests/JulianDayNumberTests/SyrianCalendarTests.swift b/Tests/JulianDayNumberTests/SyrianCalendarTests.swift
index 0cd0738..9e04086 100644
--- a/Tests/JulianDayNumberTests/SyrianCalendarTests.swift
+++ b/Tests/JulianDayNumberTests/SyrianCalendarTests.swift
@@ -8,17 +8,17 @@ import Testing
 @testable import JulianDayNumber
 
 @Suite struct SyrianCalendarTests {
-	@Test func epoch() {
-		#expect(SyrianCalendar.julianDayNumberFrom(year: 1, month: 1, day: 1) == SyrianCalendar.epoch)
-		#expect(SyrianCalendar.dateFromJulianDayNumber(SyrianCalendar.epoch) == (1, 1, 1))
+	@Test func epoch() throws {
+		#expect(try SyrianCalendar.julianDayNumberFrom(year: 1, month: 1, day: 1) == SyrianCalendar.epoch)
+		#expect(try SyrianCalendar.dateFromJulianDayNumber(SyrianCalendar.epoch) == (1, 1, 1))
 	}
 
-	@Test func julianDayNumber() {
-		#expect(SyrianCalendar.julianDayNumberFrom(year: 1, month: 1, day: 1) == 1607739)
-		#expect(SyrianCalendar.dateFromJulianDayNumber(1607739) == (1, 1, 1))
+	@Test func julianDayNumber() throws {
+		#expect(try SyrianCalendar.julianDayNumberFrom(year: 1, month: 1, day: 1) == 1607739)
+		#expect(try SyrianCalendar.dateFromJulianDayNumber(1607739) == (1, 1, 1))
 	}
 
-	@Test func leapYear() {
+	@Test func leapYear() throws {
 		#expect(!SyrianCalendar.isLeapYear(1))
 		#expect(SyrianCalendar.isLeapYear(3))
 		#expect(SyrianCalendar.isLeapYear(7))
@@ -29,8 +29,8 @@ import Testing
 
 		for y in -500...500 {
 			let isLeap = SyrianCalendar.isLeapYear(y)
-			let j = SyrianCalendar.julianDayNumberFrom(year: y, month: 6, day: isLeap ? 29 : 28)
-			let d = SyrianCalendar.dateFromJulianDayNumber(j)
+			let j = try SyrianCalendar.julianDayNumberFrom(year: y, month: 6, day: isLeap ? 29 : 28)
+			let d = try SyrianCalendar.dateFromJulianDayNumber(j)
 			#expect(d.month == 6)
 			#expect(d.day == (isLeap ? 29 : 28))
 		}
@@ -65,29 +65,29 @@ import Testing
 		#expect(SyrianCalendar.numberOfDays(inYear: 1739) == 366)
 	}
 
-	@Test func limits() {
-		#expect(SyrianCalendar.julianDateFrom(year: -999999, month: 1, day: 1) == -363642261.5)
-		#expect(SyrianCalendar.julianDateFrom(year: -99999, month: 1, day: 1) == -34917261.5)
-		#expect(SyrianCalendar.julianDateFrom(year: -9999, month: 1, day: 1) == -2044761.5)
-		#expect(SyrianCalendar.julianDateFrom(year: 9999, month: 12, day: 30) == 5259872.5)
-		#expect(SyrianCalendar.julianDateFrom(year: 99999, month: 12, day: 30) == 38132372.5)
-		#expect(SyrianCalendar.julianDateFrom(year: 999999, month: 12, day: 30) == 366857372.5)
+	@Test func limits() throws {
+		#expect(try SyrianCalendar.julianDateFrom(year: -999999, month: 1, day: 1) == -363642261.5)
+		#expect(try SyrianCalendar.julianDateFrom(year: -99999, month: 1, day: 1) == -34917261.5)
+		#expect(try SyrianCalendar.julianDateFrom(year: -9999, month: 1, day: 1) == -2044761.5)
+		#expect(try SyrianCalendar.julianDateFrom(year: 9999, month: 12, day: 30) == 5259872.5)
+		#expect(try SyrianCalendar.julianDateFrom(year: 99999, month: 12, day: 30) == 38132372.5)
+		#expect(try SyrianCalendar.julianDateFrom(year: 999999, month: 12, day: 30) == 366857372.5)
 
-		#expect(SyrianCalendar.dateAndTimeFromJulianDate(-363642261.5) == (-999999, 1, 1, 0, 0, 0))
-		#expect(SyrianCalendar.dateAndTimeFromJulianDate(-34917261.5) == (-99999, 1, 1, 0, 0, 0))
-		#expect(SyrianCalendar.dateAndTimeFromJulianDate(-2044761.5) == (-9999, 1, 1, 0, 0, 0))
-		#expect(SyrianCalendar.dateAndTimeFromJulianDate(5259872.5) == (9999, 12, 30, 0, 0, 0))
-		#expect(SyrianCalendar.dateAndTimeFromJulianDate(38132372.5) == (99999, 12, 30, 0, 0, 0))
-		#expect(SyrianCalendar.dateAndTimeFromJulianDate(366857372.5) == (999999, 12, 30, 0, 0, 0))
+		#expect(try SyrianCalendar.dateAndTimeFromJulianDate(-363642261.5) == (-999999, 1, 1, 0, 0, 0))
+		#expect(try SyrianCalendar.dateAndTimeFromJulianDate(-34917261.5) == (-99999, 1, 1, 0, 0, 0))
+		#expect(try SyrianCalendar.dateAndTimeFromJulianDate(-2044761.5) == (-9999, 1, 1, 0, 0, 0))
+		#expect(try SyrianCalendar.dateAndTimeFromJulianDate(5259872.5) == (9999, 12, 30, 0, 0, 0))
+		#expect(try SyrianCalendar.dateAndTimeFromJulianDate(38132372.5) == (99999, 12, 30, 0, 0, 0))
+		#expect(try SyrianCalendar.dateAndTimeFromJulianDate(366857372.5) == (999999, 12, 30, 0, 0, 0))
 	}
 
-	@Test func arithmeticLimits() {
-		let minDate = SyrianCalendar.dateFromJulianDayNumber(.min)
-		let minJ = SyrianCalendar.julianDayNumberFromDate(minDate)
+	@Test func arithmeticLimits() throws {
+		let minDate = try SyrianCalendar.dateFromJulianDayNumber(.min)
+		let minJ = try SyrianCalendar.julianDayNumberFromDate(minDate)
 		#expect(minJ == .min)
 
-		let maxDate = SyrianCalendar.dateFromJulianDayNumber(.max)
-		let maxJ = SyrianCalendar.julianDayNumberFromDate(maxDate)
+		let maxDate = try SyrianCalendar.dateFromJulianDayNumber(.max)
+		let maxJ = try SyrianCalendar.julianDayNumberFromDate(maxDate)
 		#expect(maxJ == .max)
 	}
 }

From 2830b160c565d3966509abbbdd46bc3dafffd13f Mon Sep 17 00:00:00 2001
From: "Stephen F. Booth" <me@sbooth.org>
Date: Mon, 1 Sep 2025 07:47:02 -0500
Subject: [PATCH 2/2] Add `try` and `throws`

---
 .../AstronomicalCalendarTests.swift                    | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/Tests/JulianDayNumberTests/AstronomicalCalendarTests.swift b/Tests/JulianDayNumberTests/AstronomicalCalendarTests.swift
index 865f102..01ef2c1 100644
--- a/Tests/JulianDayNumberTests/AstronomicalCalendarTests.swift
+++ b/Tests/JulianDayNumberTests/AstronomicalCalendarTests.swift
@@ -217,13 +217,13 @@ import Testing
 		#expect(try AstronomicalCalendar.dateAndTimeFromJulianDate(366963558.5) == (999999, 12, 31, 0, 0, 0))
 	}
 
-	@Test func arithmeticLimits() {
-		let minDate = AstronomicalCalendar.dateFromJulianDayNumber(.min)
-		let minJ = AstronomicalCalendar.julianDayNumberFromDate(minDate)
+	@Test func arithmeticLimits() throws {
+		let minDate = try AstronomicalCalendar.dateFromJulianDayNumber(.min)
+		let minJ = try AstronomicalCalendar.julianDayNumberFromDate(minDate)
 		#expect(minJ == .min)
 
-		let maxDate = AstronomicalCalendar.dateFromJulianDayNumber(.max)
-		let maxJ = AstronomicalCalendar.julianDayNumberFromDate(maxDate)
+		let maxDate = try AstronomicalCalendar.dateFromJulianDayNumber(.max)
+		let maxJ = try AstronomicalCalendar.julianDayNumberFromDate(maxDate)
 		#expect(maxJ == .max)
 
 		_ = AstronomicalCalendar.isLeapYear(.min)