diff --git a/src/datetime/tests.rs b/src/datetime/tests.rs
index bce6f5e165..64afafe130 100644
--- a/src/datetime/tests.rs
+++ b/src/datetime/tests.rs
@@ -569,12 +569,12 @@ fn test_datetime_offset() {
     let dt = Utc.with_ymd_and_hms(2014, 5, 6, 7, 8, 9).unwrap();
     assert_eq!(dt, edt.with_ymd_and_hms(2014, 5, 6, 3, 8, 9).unwrap());
     assert_eq!(
-        dt + TimeDelta::seconds(3600 + 60 + 1).unwrap(),
+        dt + TimeDelta::seconds(3600 + 60 + 1),
         Utc.with_ymd_and_hms(2014, 5, 6, 8, 9, 10).unwrap()
     );
     assert_eq!(
         dt.signed_duration_since(edt.with_ymd_and_hms(2014, 5, 6, 10, 11, 12).unwrap()),
-        TimeDelta::seconds(-7 * 3600 - 3 * 60 - 3).unwrap()
+        TimeDelta::seconds(-7 * 3600 - 3 * 60 - 3)
     );
 
     assert_eq!(*Utc.with_ymd_and_hms(2014, 5, 6, 7, 8, 9).unwrap().offset(), Utc);
@@ -1389,20 +1389,20 @@ fn test_datetime_add_assign() {
     let datetime = naivedatetime.and_utc();
     let mut datetime_add = datetime;
 
-    datetime_add += TimeDelta::seconds(60).unwrap();
-    assert_eq!(datetime_add, datetime + TimeDelta::seconds(60).unwrap());
+    datetime_add += TimeDelta::seconds(60);
+    assert_eq!(datetime_add, datetime + TimeDelta::seconds(60));
 
     let timezone = FixedOffset::east(60 * 60).unwrap();
     let datetime = datetime.with_timezone(&timezone);
     let datetime_add = datetime_add.with_timezone(&timezone);
 
-    assert_eq!(datetime_add, datetime + TimeDelta::seconds(60).unwrap());
+    assert_eq!(datetime_add, datetime + TimeDelta::seconds(60));
 
     let timezone = FixedOffset::west(2 * 60 * 60).unwrap();
     let datetime = datetime.with_timezone(&timezone);
     let datetime_add = datetime_add.with_timezone(&timezone);
 
-    assert_eq!(datetime_add, datetime + TimeDelta::seconds(60).unwrap());
+    assert_eq!(datetime_add, datetime + TimeDelta::seconds(60));
 }
 
 #[test]
diff --git a/src/format/parsed.rs b/src/format/parsed.rs
index a0a193c715..199a504f71 100644
--- a/src/format/parsed.rs
+++ b/src/format/parsed.rs
@@ -795,7 +795,7 @@ impl Parsed {
                     59 => {}
                     // `datetime` is known to be off by one second.
                     0 => {
-                        datetime -= TimeDelta::seconds(1).unwrap();
+                        datetime -= TimeDelta::seconds(1);
                     }
                     // otherwise it is impossible.
                     _ => return Err(IMPOSSIBLE),
diff --git a/src/lib.rs b/src/lib.rs
index daefd98193..f4a93d6741 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -199,11 +199,11 @@
 //! // arithmetic operations
 //! let dt1 = Utc.with_ymd_and_hms(2014, 11, 14, 8, 9, 10).unwrap();
 //! let dt2 = Utc.with_ymd_and_hms(2014, 11, 14, 10, 9, 8).unwrap();
-//! assert_eq!(dt1.signed_duration_since(dt2), TimeDelta::seconds(-2 * 3600 + 2).unwrap());
-//! assert_eq!(dt2.signed_duration_since(dt1), TimeDelta::seconds(2 * 3600 - 2).unwrap());
-//! assert_eq!(Utc.with_ymd_and_hms(1970, 1, 1, 0, 0, 0).unwrap() + TimeDelta::seconds(1_000_000_000).unwrap(),
+//! assert_eq!(dt1.signed_duration_since(dt2), TimeDelta::seconds(-2 * 3600 + 2));
+//! assert_eq!(dt2.signed_duration_since(dt1), TimeDelta::seconds(2 * 3600 - 2));
+//! assert_eq!(Utc.with_ymd_and_hms(1970, 1, 1, 0, 0, 0).unwrap() + TimeDelta::seconds(1_000_000_000),
 //!            Utc.with_ymd_and_hms(2001, 9, 9, 1, 46, 40).unwrap());
-//! assert_eq!(Utc.with_ymd_and_hms(1970, 1, 1, 0, 0, 0).unwrap() - TimeDelta::seconds(1_000_000_000).unwrap(),
+//! assert_eq!(Utc.with_ymd_and_hms(1970, 1, 1, 0, 0, 0).unwrap() - TimeDelta::seconds(1_000_000_000),
 //!            Utc.with_ymd_and_hms(1938, 4, 24, 22, 13, 20).unwrap());
 //! ```
 //!
diff --git a/src/naive/date/mod.rs b/src/naive/date/mod.rs
index 6aeb6a7d80..a6c5104f3c 100644
--- a/src/naive/date/mod.rs
+++ b/src/naive/date/mod.rs
@@ -1699,8 +1699,8 @@ impl Datelike for NaiveDate {
 /// let from_ymd = |y, m, d| NaiveDate::from_ymd(y, m, d).unwrap();
 ///
 /// assert_eq!(from_ymd(2014, 1, 1) + TimeDelta::zero(), from_ymd(2014, 1, 1));
-/// assert_eq!(from_ymd(2014, 1, 1) + TimeDelta::seconds(86399).unwrap(), from_ymd(2014, 1, 1));
-/// assert_eq!(from_ymd(2014, 1, 1) + TimeDelta::seconds(-86399).unwrap(), from_ymd(2014, 1, 1));
+/// assert_eq!(from_ymd(2014, 1, 1) + TimeDelta::seconds(86399), from_ymd(2014, 1, 1));
+/// assert_eq!(from_ymd(2014, 1, 1) + TimeDelta::seconds(-86399), from_ymd(2014, 1, 1));
 /// assert_eq!(from_ymd(2014, 1, 1) + TimeDelta::days(1), from_ymd(2014, 1, 2));
 /// assert_eq!(from_ymd(2014, 1, 1) + TimeDelta::days(-1), from_ymd(2013, 12, 31));
 /// assert_eq!(from_ymd(2014, 1, 1) + TimeDelta::days(364), from_ymd(2014, 12, 31));
@@ -1842,8 +1842,8 @@ impl Sub<Days> for NaiveDate {
 /// let from_ymd = |y, m, d| NaiveDate::from_ymd(y, m, d).unwrap();
 ///
 /// assert_eq!(from_ymd(2014, 1, 1) - TimeDelta::zero(), from_ymd(2014, 1, 1));
-/// assert_eq!(from_ymd(2014, 1, 1) - TimeDelta::seconds(86399).unwrap(), from_ymd(2014, 1, 1));
-/// assert_eq!(from_ymd(2014, 1, 1) - TimeDelta::seconds(-86399).unwrap(), from_ymd(2014, 1, 1));
+/// assert_eq!(from_ymd(2014, 1, 1) - TimeDelta::seconds(86399), from_ymd(2014, 1, 1));
+/// assert_eq!(from_ymd(2014, 1, 1) - TimeDelta::seconds(-86399), from_ymd(2014, 1, 1));
 /// assert_eq!(from_ymd(2014, 1, 1) - TimeDelta::days(1), from_ymd(2013, 12, 31));
 /// assert_eq!(from_ymd(2014, 1, 1) - TimeDelta::days(-1), from_ymd(2014, 1, 2));
 /// assert_eq!(from_ymd(2014, 1, 1) - TimeDelta::days(364), from_ymd(2013, 1, 2));
diff --git a/src/naive/date/tests.rs b/src/naive/date/tests.rs
index d666736e2a..7711edec2d 100644
--- a/src/naive/date/tests.rs
+++ b/src/naive/date/tests.rs
@@ -452,9 +452,9 @@ fn test_date_checked_add_signed() {
     let ymd = |y, m, d| NaiveDate::from_ymd(y, m, d).ok();
 
     check(ymd(2014, 1, 1), TimeDelta::zero(), ymd(2014, 1, 1));
-    check(ymd(2014, 1, 1), TimeDelta::seconds(86399).unwrap(), ymd(2014, 1, 1));
+    check(ymd(2014, 1, 1), TimeDelta::seconds(86399), ymd(2014, 1, 1));
     // always round towards zero
-    check(ymd(2014, 1, 1), TimeDelta::seconds(-86399).unwrap(), ymd(2014, 1, 1));
+    check(ymd(2014, 1, 1), TimeDelta::seconds(-86399), ymd(2014, 1, 1));
     check(ymd(2014, 1, 1), TimeDelta::days(1), ymd(2014, 1, 2));
     check(ymd(2014, 1, 1), TimeDelta::days(-1), ymd(2013, 12, 31));
     check(ymd(2014, 1, 1), TimeDelta::days(364), ymd(2014, 12, 31));
diff --git a/src/naive/datetime/mod.rs b/src/naive/datetime/mod.rs
index 30910541d4..2f8ecbb61e 100644
--- a/src/naive/datetime/mod.rs
+++ b/src/naive/datetime/mod.rs
@@ -254,17 +254,11 @@ impl NaiveDateTime {
     /// let d = from_ymd(2016, 7, 8);
     /// let hms = |h, m, s| d.and_hms(h, m, s).unwrap();
     /// assert_eq!(hms(3, 5, 7).checked_add_signed(TimeDelta::zero()), Some(hms(3, 5, 7)));
-    /// assert_eq!(hms(3, 5, 7).checked_add_signed(TimeDelta::seconds(1).unwrap()), Some(hms(3, 5, 8)));
+    /// assert_eq!(hms(3, 5, 7).checked_add_signed(TimeDelta::seconds(1)), Some(hms(3, 5, 8)));
+    /// assert_eq!(hms(3, 5, 7).checked_add_signed(TimeDelta::seconds(-1)), Some(hms(3, 5, 6)));
+    /// assert_eq!(hms(3, 5, 7).checked_add_signed(TimeDelta::seconds(3600 + 60)), Some(hms(4, 6, 7)));
     /// assert_eq!(
-    ///     hms(3, 5, 7).checked_add_signed(TimeDelta::seconds(-1).unwrap()),
-    ///     Some(hms(3, 5, 6))
-    /// );
-    /// assert_eq!(
-    ///     hms(3, 5, 7).checked_add_signed(TimeDelta::seconds(3600 + 60).unwrap()),
-    ///     Some(hms(4, 6, 7))
-    /// );
-    /// assert_eq!(
-    ///     hms(3, 5, 7).checked_add_signed(TimeDelta::seconds(86_400).unwrap()),
+    ///     hms(3, 5, 7).checked_add_signed(TimeDelta::seconds(86_400)),
     ///     Some(from_ymd(2016, 7, 9).and_hms(3, 5, 7).unwrap())
     /// );
     ///
@@ -299,9 +293,9 @@ impl NaiveDateTime {
     ///            Some(hmsm(3, 5, 59, 1_800)));
     /// assert_eq!(leap.checked_add_signed(TimeDelta::milliseconds(800).unwrap()),
     ///            Some(hmsm(3, 6, 0, 100)));
-    /// assert_eq!(leap.checked_add_signed(TimeDelta::seconds(10).unwrap()),
+    /// assert_eq!(leap.checked_add_signed(TimeDelta::seconds(10)),
     ///            Some(hmsm(3, 6, 9, 300)));
-    /// assert_eq!(leap.checked_add_signed(TimeDelta::seconds(-10).unwrap()),
+    /// assert_eq!(leap.checked_add_signed(TimeDelta::seconds(-10)),
     ///            Some(hmsm(3, 5, 50, 300)));
     /// assert_eq!(leap.checked_add_signed(TimeDelta::days(1)),
     ///            Some(from_ymd(2016, 7, 9).and_hms_milli(3, 5, 59, 300).unwrap()));
@@ -309,7 +303,7 @@ impl NaiveDateTime {
     #[must_use]
     pub const fn checked_add_signed(self, rhs: TimeDelta) -> Option<NaiveDateTime> {
         let (time, remainder) = self.time.overflowing_add_signed(rhs);
-        let remainder = try_opt!(TimeDelta::seconds(remainder));
+        let remainder = try_opt!(TimeDelta::new(remainder, 0));
         let date = try_opt!(self.date.checked_add_signed(remainder));
         Some(NaiveDateTime { date, time })
     }
@@ -435,17 +429,11 @@ impl NaiveDateTime {
     /// let d = from_ymd(2016, 7, 8);
     /// let hms = |h, m, s| d.and_hms(h, m, s).unwrap();
     /// assert_eq!(hms(3, 5, 7).checked_sub_signed(TimeDelta::zero()), Some(hms(3, 5, 7)));
-    /// assert_eq!(hms(3, 5, 7).checked_sub_signed(TimeDelta::seconds(1).unwrap()), Some(hms(3, 5, 6)));
-    /// assert_eq!(
-    ///     hms(3, 5, 7).checked_sub_signed(TimeDelta::seconds(-1).unwrap()),
-    ///     Some(hms(3, 5, 8))
-    /// );
-    /// assert_eq!(
-    ///     hms(3, 5, 7).checked_sub_signed(TimeDelta::seconds(3600 + 60).unwrap()),
-    ///     Some(hms(2, 4, 7))
-    /// );
+    /// assert_eq!(hms(3, 5, 7).checked_sub_signed(TimeDelta::seconds(1)), Some(hms(3, 5, 6)));
+    /// assert_eq!(hms(3, 5, 7).checked_sub_signed(TimeDelta::seconds(-1)), Some(hms(3, 5, 8)));
+    /// assert_eq!(hms(3, 5, 7).checked_sub_signed(TimeDelta::seconds(3600 + 60)), Some(hms(2, 4, 7)));
     /// assert_eq!(
-    ///     hms(3, 5, 7).checked_sub_signed(TimeDelta::seconds(86_400).unwrap()),
+    ///     hms(3, 5, 7).checked_sub_signed(TimeDelta::seconds(86_400)),
     ///     Some(from_ymd(2016, 7, 7).and_hms(3, 5, 7).unwrap())
     /// );
     ///
@@ -478,7 +466,7 @@ impl NaiveDateTime {
     ///            Some(hmsm(3, 5, 59, 1_100)));
     /// assert_eq!(leap.checked_sub_signed(TimeDelta::milliseconds(500).unwrap()),
     ///            Some(hmsm(3, 5, 59, 800)));
-    /// assert_eq!(leap.checked_sub_signed(TimeDelta::seconds(60).unwrap()),
+    /// assert_eq!(leap.checked_sub_signed(TimeDelta::seconds(60)),
     ///            Some(hmsm(3, 5, 0, 300)));
     /// assert_eq!(leap.checked_sub_signed(TimeDelta::days(1)),
     ///            Some(from_ymd(2016, 7, 7).and_hms_milli(3, 6, 0, 300).unwrap()));
@@ -486,7 +474,7 @@ impl NaiveDateTime {
     #[must_use]
     pub const fn checked_sub_signed(self, rhs: TimeDelta) -> Option<NaiveDateTime> {
         let (time, remainder) = self.time.overflowing_sub_signed(rhs);
-        let remainder = try_opt!(TimeDelta::seconds(remainder));
+        let remainder = try_opt!(TimeDelta::new(remainder, 0));
         let date = try_opt!(self.date.checked_sub_signed(remainder));
         Some(NaiveDateTime { date, time })
     }
@@ -560,15 +548,14 @@ impl NaiveDateTime {
     /// let d = from_ymd(2016, 7, 8);
     /// assert_eq!(
     ///     d.and_hms(3, 5, 7).unwrap().signed_duration_since(d.and_hms(2, 4, 6).unwrap()),
-    ///     TimeDelta::seconds(3600 + 60 + 1).unwrap()
+    ///     TimeDelta::seconds(3600 + 60 + 1)
     /// );
     ///
     /// // July 8 is 190th day in the year 2016
     /// let d0 = from_ymd(2016, 1, 1);
     /// assert_eq!(
     ///     d.and_hms_milli(0, 7, 6, 500).unwrap().signed_duration_since(d0.and_hms(0, 0, 0).unwrap()),
-    ///     TimeDelta::seconds(189 * 86_400 + 7 * 60 + 6).unwrap()
-    ///         + TimeDelta::milliseconds(500).unwrap()
+    ///     TimeDelta::seconds(189 * 86_400 + 7 * 60 + 6) + TimeDelta::milliseconds(500).unwrap()
     /// );
     /// ```
     ///
@@ -581,11 +568,11 @@ impl NaiveDateTime {
     /// let leap = from_ymd(2015, 6, 30).and_hms_milli(23, 59, 59, 1_500).unwrap();
     /// assert_eq!(
     ///     leap.signed_duration_since(from_ymd(2015, 6, 30).and_hms(23, 0, 0).unwrap()),
-    ///     TimeDelta::seconds(3600).unwrap() + TimeDelta::milliseconds(500).unwrap()
+    ///     TimeDelta::seconds(3600) + TimeDelta::milliseconds(500).unwrap()
     /// );
     /// assert_eq!(
     ///     from_ymd(2015, 7, 1).and_hms(1, 0, 0).unwrap().signed_duration_since(leap),
-    ///     TimeDelta::seconds(3600).unwrap() - TimeDelta::milliseconds(500).unwrap()
+    ///     TimeDelta::seconds(3600) - TimeDelta::milliseconds(500).unwrap()
     /// );
     /// ```
     #[must_use]
@@ -1311,11 +1298,11 @@ impl Timelike for NaiveDateTime {
 /// let d = from_ymd(2016, 7, 8);
 /// let hms = |h, m, s| d.and_hms(h, m, s).unwrap();
 /// assert_eq!(hms(3, 5, 7) + TimeDelta::zero(), hms(3, 5, 7));
-/// assert_eq!(hms(3, 5, 7) + TimeDelta::seconds(1).unwrap(), hms(3, 5, 8));
-/// assert_eq!(hms(3, 5, 7) + TimeDelta::seconds(-1).unwrap(), hms(3, 5, 6));
-/// assert_eq!(hms(3, 5, 7) + TimeDelta::seconds(3600 + 60).unwrap(), hms(4, 6, 7));
+/// assert_eq!(hms(3, 5, 7) + TimeDelta::seconds(1), hms(3, 5, 8));
+/// assert_eq!(hms(3, 5, 7) + TimeDelta::seconds(-1), hms(3, 5, 6));
+/// assert_eq!(hms(3, 5, 7) + TimeDelta::seconds(3600 + 60), hms(4, 6, 7));
 /// assert_eq!(
-///     hms(3, 5, 7) + TimeDelta::seconds(86_400).unwrap(),
+///     hms(3, 5, 7) + TimeDelta::seconds(86_400),
 ///     from_ymd(2016, 7, 9).and_hms(3, 5, 7).unwrap()
 /// );
 /// assert_eq!(hms(3, 5, 7) + TimeDelta::days(365), from_ymd(2017, 7, 8).and_hms(3, 5, 7).unwrap());
@@ -1336,8 +1323,8 @@ impl Timelike for NaiveDateTime {
 /// assert_eq!(leap + TimeDelta::milliseconds(-500).unwrap(), hmsm(3, 5, 59, 800));
 /// assert_eq!(leap + TimeDelta::milliseconds(500).unwrap(), hmsm(3, 5, 59, 1_800));
 /// assert_eq!(leap + TimeDelta::milliseconds(800).unwrap(), hmsm(3, 6, 0, 100));
-/// assert_eq!(leap + TimeDelta::seconds(10).unwrap(), hmsm(3, 6, 9, 300));
-/// assert_eq!(leap + TimeDelta::seconds(-10).unwrap(), hmsm(3, 5, 50, 300));
+/// assert_eq!(leap + TimeDelta::seconds(10), hmsm(3, 6, 9, 300));
+/// assert_eq!(leap + TimeDelta::seconds(-10), hmsm(3, 5, 50, 300));
 /// assert_eq!(leap + TimeDelta::days(1),
 ///            from_ymd(2016, 7, 9).and_hms_milli(3, 5, 59, 300).unwrap());
 /// ```
@@ -1493,11 +1480,11 @@ impl Add<Months> for NaiveDateTime {
 /// let d = from_ymd(2016, 7, 8);
 /// let hms = |h, m, s| d.and_hms(h, m, s).unwrap();
 /// assert_eq!(hms(3, 5, 7) - TimeDelta::zero(), hms(3, 5, 7));
-/// assert_eq!(hms(3, 5, 7) - TimeDelta::seconds(1).unwrap(), hms(3, 5, 6));
-/// assert_eq!(hms(3, 5, 7) - TimeDelta::seconds(-1).unwrap(), hms(3, 5, 8));
-/// assert_eq!(hms(3, 5, 7) - TimeDelta::seconds(3600 + 60).unwrap(), hms(2, 4, 7));
+/// assert_eq!(hms(3, 5, 7) - TimeDelta::seconds(1), hms(3, 5, 6));
+/// assert_eq!(hms(3, 5, 7) - TimeDelta::seconds(-1), hms(3, 5, 8));
+/// assert_eq!(hms(3, 5, 7) - TimeDelta::seconds(3600 + 60), hms(2, 4, 7));
 /// assert_eq!(
-///     hms(3, 5, 7) - TimeDelta::seconds(86_400).unwrap(),
+///     hms(3, 5, 7) - TimeDelta::seconds(86_400),
 ///     from_ymd(2016, 7, 7).and_hms(3, 5, 7).unwrap()
 /// );
 /// assert_eq!(hms(3, 5, 7) - TimeDelta::days(365), from_ymd(2015, 7, 9).and_hms(3, 5, 7).unwrap());
@@ -1517,7 +1504,7 @@ impl Add<Months> for NaiveDateTime {
 /// assert_eq!(leap - TimeDelta::zero(), hmsm(3, 5, 59, 1_300));
 /// assert_eq!(leap - TimeDelta::milliseconds(200).unwrap(), hmsm(3, 5, 59, 1_100));
 /// assert_eq!(leap - TimeDelta::milliseconds(500).unwrap(), hmsm(3, 5, 59, 800));
-/// assert_eq!(leap - TimeDelta::seconds(60).unwrap(), hmsm(3, 5, 0, 300));
+/// assert_eq!(leap - TimeDelta::seconds(60), hmsm(3, 5, 0, 300));
 /// assert_eq!(leap - TimeDelta::days(1),
 ///            from_ymd(2016, 7, 7).and_hms_milli(3, 6, 0, 300).unwrap());
 /// ```
@@ -1661,15 +1648,14 @@ impl Sub<Months> for NaiveDateTime {
 /// let d = from_ymd(2016, 7, 8);
 /// assert_eq!(
 ///     d.and_hms(3, 5, 7).unwrap() - d.and_hms(2, 4, 6).unwrap(),
-///     TimeDelta::seconds(3600 + 60 + 1).unwrap()
+///     TimeDelta::seconds(3600 + 60 + 1)
 /// );
 ///
 /// // July 8 is 190th day in the year 2016
 /// let d0 = from_ymd(2016, 1, 1);
 /// assert_eq!(
 ///     d.and_hms_milli(0, 7, 6, 500).unwrap() - d0.and_hms(0, 0, 0).unwrap(),
-///     TimeDelta::seconds(189 * 86_400 + 7 * 60 + 6).unwrap()
-///         + TimeDelta::milliseconds(500).unwrap()
+///     TimeDelta::seconds(189 * 86_400 + 7 * 60 + 6) + TimeDelta::milliseconds(500).unwrap()
 /// );
 /// ```
 ///
@@ -1682,11 +1668,11 @@ impl Sub<Months> for NaiveDateTime {
 /// let leap = from_ymd(2015, 6, 30).and_hms_milli(23, 59, 59, 1_500).unwrap();
 /// assert_eq!(
 ///     leap - from_ymd(2015, 6, 30).and_hms(23, 0, 0).unwrap(),
-///     TimeDelta::seconds(3600).unwrap() + TimeDelta::milliseconds(500).unwrap()
+///     TimeDelta::seconds(3600) + TimeDelta::milliseconds(500).unwrap()
 /// );
 /// assert_eq!(
 ///     from_ymd(2015, 7, 1).and_hms(1, 0, 0).unwrap() - leap,
-///     TimeDelta::seconds(3600).unwrap() - TimeDelta::milliseconds(500).unwrap()
+///     TimeDelta::seconds(3600) - TimeDelta::milliseconds(500).unwrap()
 /// );
 /// ```
 impl Sub<NaiveDateTime> for NaiveDateTime {
diff --git a/src/naive/datetime/tests.rs b/src/naive/datetime/tests.rs
index f47e6ca2ff..10401cdaa7 100644
--- a/src/naive/datetime/tests.rs
+++ b/src/naive/datetime/tests.rs
@@ -15,7 +15,7 @@ fn test_datetime_add() {
         assert_eq!(lhs.checked_add_signed(rhs), sum);
         assert_eq!(lhs.checked_sub_signed(-rhs), sum);
     }
-    let seconds = |s| TimeDelta::seconds(s).unwrap();
+    let seconds = TimeDelta::seconds;
 
     check((2014, 5, 6, 7, 8, 9), seconds(3600 + 60 + 1), Some((2014, 5, 6, 8, 9, 10)));
     check((2014, 5, 6, 7, 8, 9), seconds(-(3600 + 60 + 1)), Some((2014, 5, 6, 6, 7, 8)));
@@ -52,19 +52,19 @@ fn test_datetime_sub() {
     assert_eq!(since(ymdhms(2014, 5, 6, 7, 8, 9), ymdhms(2014, 5, 6, 7, 8, 9)), TimeDelta::zero());
     assert_eq!(
         since(ymdhms(2014, 5, 6, 7, 8, 10), ymdhms(2014, 5, 6, 7, 8, 9)),
-        TimeDelta::seconds(1).unwrap()
+        TimeDelta::seconds(1)
     );
     assert_eq!(
         since(ymdhms(2014, 5, 6, 7, 8, 9), ymdhms(2014, 5, 6, 7, 8, 10)),
-        TimeDelta::seconds(-1).unwrap()
+        TimeDelta::seconds(-1)
     );
     assert_eq!(
         since(ymdhms(2014, 5, 7, 7, 8, 9), ymdhms(2014, 5, 6, 7, 8, 10)),
-        TimeDelta::seconds(86399).unwrap()
+        TimeDelta::seconds(86399)
     );
     assert_eq!(
         since(ymdhms(2001, 9, 9, 1, 46, 39), ymdhms(1970, 1, 1, 0, 0, 0)),
-        TimeDelta::seconds(999_999_999).unwrap()
+        TimeDelta::seconds(999_999_999)
     );
 }
 
diff --git a/src/naive/time/mod.rs b/src/naive/time/mod.rs
index 6714263d3c..f91a3aeec3 100644
--- a/src/naive/time/mod.rs
+++ b/src/naive/time/mod.rs
@@ -635,25 +635,16 @@ impl NaiveTime {
     ///     since(from_hmsm(3, 5, 7, 900), from_hmsm(3, 5, 6, 925)),
     ///     TimeDelta::milliseconds(975).unwrap()
     /// );
-    /// assert_eq!(
-    ///     since(from_hmsm(3, 5, 7, 900), from_hmsm(3, 5, 0, 900)),
-    ///     TimeDelta::seconds(7).unwrap()
-    /// );
-    /// assert_eq!(
-    ///     since(from_hmsm(3, 5, 7, 900), from_hmsm(3, 0, 7, 900)),
-    ///     TimeDelta::seconds(5 * 60).unwrap()
-    /// );
+    /// assert_eq!(since(from_hmsm(3, 5, 7, 900), from_hmsm(3, 5, 0, 900)), TimeDelta::seconds(7));
+    /// assert_eq!(since(from_hmsm(3, 5, 7, 900), from_hmsm(3, 0, 7, 900)), TimeDelta::seconds(5 * 60));
     /// assert_eq!(
     ///     since(from_hmsm(3, 5, 7, 900), from_hmsm(0, 5, 7, 900)),
-    ///     TimeDelta::seconds(3 * 3600).unwrap()
-    /// );
-    /// assert_eq!(
-    ///     since(from_hmsm(3, 5, 7, 900), from_hmsm(4, 5, 7, 900)),
-    ///     TimeDelta::seconds(-3600).unwrap()
+    ///     TimeDelta::seconds(3 * 3600)
     /// );
+    /// assert_eq!(since(from_hmsm(3, 5, 7, 900), from_hmsm(4, 5, 7, 900)), TimeDelta::seconds(-3600));
     /// assert_eq!(
     ///     since(from_hmsm(3, 5, 7, 900), from_hmsm(2, 4, 6, 800)),
-    ///     TimeDelta::seconds(3600 + 60 + 1).unwrap() + TimeDelta::milliseconds(100).unwrap()
+    ///     TimeDelta::seconds(3600 + 60 + 1) + TimeDelta::milliseconds(100).unwrap()
     /// );
     /// ```
     ///
@@ -665,15 +656,15 @@ impl NaiveTime {
     /// # let from_hmsm = |h, m, s, milli| { NaiveTime::from_hms_milli(h, m, s, milli).unwrap() };
     /// # let since = NaiveTime::signed_duration_since;
     /// assert_eq!(since(from_hmsm(3, 0, 59, 1_000), from_hmsm(3, 0, 59, 0)),
-    ///            TimeDelta::seconds(1).unwrap());
+    ///            TimeDelta::seconds(1));
     /// assert_eq!(since(from_hmsm(3, 0, 59, 1_500), from_hmsm(3, 0, 59, 0)),
     ///            TimeDelta::milliseconds(1500).unwrap());
     /// assert_eq!(since(from_hmsm(3, 0, 59, 1_000), from_hmsm(3, 0, 0, 0)),
-    ///            TimeDelta::seconds(60).unwrap());
+    ///            TimeDelta::seconds(60));
     /// assert_eq!(since(from_hmsm(3, 0, 0, 0), from_hmsm(2, 59, 59, 1_000)),
-    ///            TimeDelta::seconds(1).unwrap());
+    ///            TimeDelta::seconds(1));
     /// assert_eq!(since(from_hmsm(3, 0, 59, 1_000), from_hmsm(2, 59, 59, 1_000)),
-    ///            TimeDelta::seconds(61).unwrap());
+    ///            TimeDelta::seconds(61));
     /// ```
     #[must_use]
     pub const fn signed_duration_since(self, rhs: NaiveTime) -> TimeDelta {
@@ -1082,11 +1073,11 @@ impl Timelike for NaiveTime {
 /// let from_hmsm = |h, m, s, milli| NaiveTime::from_hms_milli(h, m, s, milli).unwrap();
 ///
 /// assert_eq!(from_hmsm(3, 5, 7, 0) + TimeDelta::zero(), from_hmsm(3, 5, 7, 0));
-/// assert_eq!(from_hmsm(3, 5, 7, 0) + TimeDelta::seconds(1).unwrap(), from_hmsm(3, 5, 8, 0));
-/// assert_eq!(from_hmsm(3, 5, 7, 0) + TimeDelta::seconds(-1).unwrap(), from_hmsm(3, 5, 6, 0));
-/// assert_eq!(from_hmsm(3, 5, 7, 0) + TimeDelta::seconds(60 + 4).unwrap(), from_hmsm(3, 6, 11, 0));
+/// assert_eq!(from_hmsm(3, 5, 7, 0) + TimeDelta::seconds(1), from_hmsm(3, 5, 8, 0));
+/// assert_eq!(from_hmsm(3, 5, 7, 0) + TimeDelta::seconds(-1), from_hmsm(3, 5, 6, 0));
+/// assert_eq!(from_hmsm(3, 5, 7, 0) + TimeDelta::seconds(60 + 4), from_hmsm(3, 6, 11, 0));
 /// assert_eq!(
-///     from_hmsm(3, 5, 7, 0) + TimeDelta::seconds(7 * 60 * 60 - 6 * 60).unwrap(),
+///     from_hmsm(3, 5, 7, 0) + TimeDelta::seconds(7 * 60 * 60 - 6 * 60),
 ///     from_hmsm(9, 59, 7, 0)
 /// );
 /// assert_eq!(
@@ -1108,8 +1099,8 @@ impl Timelike for NaiveTime {
 /// ```
 /// # use chrono::{TimeDelta, NaiveTime};
 /// # let from_hmsm = |h, m, s, milli| { NaiveTime::from_hms_milli(h, m, s, milli).unwrap() };
-/// assert_eq!(from_hmsm(3, 5, 7, 0) + TimeDelta::seconds(22*60*60).unwrap(), from_hmsm(1, 5, 7, 0));
-/// assert_eq!(from_hmsm(3, 5, 7, 0) + TimeDelta::seconds(-8*60*60).unwrap(), from_hmsm(19, 5, 7, 0));
+/// assert_eq!(from_hmsm(3, 5, 7, 0) + TimeDelta::seconds(22 * 60 * 60), from_hmsm(1, 5, 7, 0));
+/// assert_eq!(from_hmsm(3, 5, 7, 0) + TimeDelta::seconds(-8 * 60 * 60), from_hmsm(19, 5, 7, 0));
 /// assert_eq!(from_hmsm(3, 5, 7, 0) + TimeDelta::days(800), from_hmsm(3, 5, 7, 0));
 /// ```
 ///
@@ -1123,8 +1114,8 @@ impl Timelike for NaiveTime {
 /// assert_eq!(leap + TimeDelta::milliseconds(-500).unwrap(), from_hmsm(3, 5, 59, 800));
 /// assert_eq!(leap + TimeDelta::milliseconds(500).unwrap(), from_hmsm(3, 5, 59, 1_800));
 /// assert_eq!(leap + TimeDelta::milliseconds(800).unwrap(), from_hmsm(3, 6, 0, 100));
-/// assert_eq!(leap + TimeDelta::seconds(10).unwrap(), from_hmsm(3, 6, 9, 300));
-/// assert_eq!(leap + TimeDelta::seconds(-10).unwrap(), from_hmsm(3, 5, 50, 300));
+/// assert_eq!(leap + TimeDelta::seconds(10), from_hmsm(3, 6, 9, 300));
+/// assert_eq!(leap + TimeDelta::seconds(-10), from_hmsm(3, 5, 50, 300));
 /// assert_eq!(leap + TimeDelta::days(1), from_hmsm(3, 5, 59, 300));
 /// ```
 ///
@@ -1209,10 +1200,10 @@ impl Add<FixedOffset> for NaiveTime {
 /// let from_hmsm = |h, m, s, milli| NaiveTime::from_hms_milli(h, m, s, milli).unwrap();
 ///
 /// assert_eq!(from_hmsm(3, 5, 7, 0) - TimeDelta::zero(), from_hmsm(3, 5, 7, 0));
-/// assert_eq!(from_hmsm(3, 5, 7, 0) - TimeDelta::seconds(1).unwrap(), from_hmsm(3, 5, 6, 0));
-/// assert_eq!(from_hmsm(3, 5, 7, 0) - TimeDelta::seconds(60 + 5).unwrap(), from_hmsm(3, 4, 2, 0));
+/// assert_eq!(from_hmsm(3, 5, 7, 0) - TimeDelta::seconds(1), from_hmsm(3, 5, 6, 0));
+/// assert_eq!(from_hmsm(3, 5, 7, 0) - TimeDelta::seconds(60 + 5), from_hmsm(3, 4, 2, 0));
 /// assert_eq!(
-///     from_hmsm(3, 5, 7, 0) - TimeDelta::seconds(2 * 60 * 60 + 6 * 60).unwrap(),
+///     from_hmsm(3, 5, 7, 0) - TimeDelta::seconds(2 * 60 * 60 + 6 * 60),
 ///     from_hmsm(0, 59, 7, 0)
 /// );
 /// assert_eq!(
@@ -1230,7 +1221,7 @@ impl Add<FixedOffset> for NaiveTime {
 /// ```
 /// # use chrono::{TimeDelta, NaiveTime};
 /// # let from_hmsm = |h, m, s, milli| { NaiveTime::from_hms_milli(h, m, s, milli).unwrap() };
-/// assert_eq!(from_hmsm(3, 5, 7, 0) - TimeDelta::seconds(8*60*60).unwrap(), from_hmsm(19, 5, 7, 0));
+/// assert_eq!(from_hmsm(3, 5, 7, 0) - TimeDelta::seconds(8 * 60 * 60), from_hmsm(19, 5, 7, 0));
 /// assert_eq!(from_hmsm(3, 5, 7, 0) - TimeDelta::days(800), from_hmsm(3, 5, 7, 0));
 /// ```
 ///
@@ -1243,7 +1234,7 @@ impl Add<FixedOffset> for NaiveTime {
 /// assert_eq!(leap - TimeDelta::zero(), from_hmsm(3, 5, 59, 1_300));
 /// assert_eq!(leap - TimeDelta::milliseconds(200).unwrap(), from_hmsm(3, 5, 59, 1_100));
 /// assert_eq!(leap - TimeDelta::milliseconds(500).unwrap(), from_hmsm(3, 5, 59, 800));
-/// assert_eq!(leap - TimeDelta::seconds(60).unwrap(), from_hmsm(3, 5, 0, 300));
+/// assert_eq!(leap - TimeDelta::seconds(60), from_hmsm(3, 5, 0, 300));
 /// assert_eq!(leap - TimeDelta::days(1), from_hmsm(3, 6, 0, 300));
 /// ```
 ///
@@ -1339,22 +1330,13 @@ impl Sub<FixedOffset> for NaiveTime {
 ///     from_hmsm(3, 5, 7, 900) - from_hmsm(3, 5, 6, 925),
 ///     TimeDelta::milliseconds(975).unwrap()
 /// );
-/// assert_eq!(from_hmsm(3, 5, 7, 900) - from_hmsm(3, 5, 0, 900), TimeDelta::seconds(7).unwrap());
-/// assert_eq!(
-///     from_hmsm(3, 5, 7, 900) - from_hmsm(3, 0, 7, 900),
-///     TimeDelta::seconds(5 * 60).unwrap()
-/// );
-/// assert_eq!(
-///     from_hmsm(3, 5, 7, 900) - from_hmsm(0, 5, 7, 900),
-///     TimeDelta::seconds(3 * 3600).unwrap()
-/// );
-/// assert_eq!(
-///     from_hmsm(3, 5, 7, 900) - from_hmsm(4, 5, 7, 900),
-///     TimeDelta::seconds(-3600).unwrap()
-/// );
+/// assert_eq!(from_hmsm(3, 5, 7, 900) - from_hmsm(3, 5, 0, 900), TimeDelta::seconds(7));
+/// assert_eq!(from_hmsm(3, 5, 7, 900) - from_hmsm(3, 0, 7, 900), TimeDelta::seconds(5 * 60));
+/// assert_eq!(from_hmsm(3, 5, 7, 900) - from_hmsm(0, 5, 7, 900), TimeDelta::seconds(3 * 3600));
+/// assert_eq!(from_hmsm(3, 5, 7, 900) - from_hmsm(4, 5, 7, 900), TimeDelta::seconds(-3600));
 /// assert_eq!(
 ///     from_hmsm(3, 5, 7, 900) - from_hmsm(2, 4, 6, 800),
-///     TimeDelta::seconds(3600 + 60 + 1).unwrap() + TimeDelta::milliseconds(100).unwrap()
+///     TimeDelta::seconds(3600 + 60 + 1) + TimeDelta::milliseconds(100).unwrap()
 /// );
 /// ```
 ///
@@ -1364,13 +1346,12 @@ impl Sub<FixedOffset> for NaiveTime {
 /// ```
 /// # use chrono::{TimeDelta, NaiveTime};
 /// # let from_hmsm = |h, m, s, milli| { NaiveTime::from_hms_milli(h, m, s, milli).unwrap() };
-/// assert_eq!(from_hmsm(3, 0, 59, 1_000) - from_hmsm(3, 0, 59, 0), TimeDelta::seconds(1).unwrap());
+/// assert_eq!(from_hmsm(3, 0, 59, 1_000) - from_hmsm(3, 0, 59, 0), TimeDelta::seconds(1));
 /// assert_eq!(from_hmsm(3, 0, 59, 1_500) - from_hmsm(3, 0, 59, 0),
 ///            TimeDelta::milliseconds(1500).unwrap());
-/// assert_eq!(from_hmsm(3, 0, 59, 1_000) - from_hmsm(3, 0, 0, 0), TimeDelta::seconds(60).unwrap());
-/// assert_eq!(from_hmsm(3, 0, 0, 0) - from_hmsm(2, 59, 59, 1_000), TimeDelta::seconds(1).unwrap());
-/// assert_eq!(from_hmsm(3, 0, 59, 1_000) - from_hmsm(2, 59, 59, 1_000),
-///            TimeDelta::seconds(61).unwrap());
+/// assert_eq!(from_hmsm(3, 0, 59, 1_000) - from_hmsm(3, 0, 0, 0), TimeDelta::seconds(60));
+/// assert_eq!(from_hmsm(3, 0, 0, 0) - from_hmsm(2, 59, 59, 1_000), TimeDelta::seconds(1));
+/// assert_eq!(from_hmsm(3, 0, 59, 1_000) - from_hmsm(2, 59, 59, 1_000), TimeDelta::seconds(61));
 /// ```
 impl Sub<NaiveTime> for NaiveTime {
     type Output = TimeDelta;
diff --git a/src/naive/time/tests.rs b/src/naive/time/tests.rs
index 3d2d2125f8..5219a9e137 100644
--- a/src/naive/time/tests.rs
+++ b/src/naive/time/tests.rs
@@ -110,8 +110,8 @@ fn test_time_add() {
     check!(hmsm(3, 5, 59, 1_300), TimeDelta::milliseconds(100).unwrap(), hmsm(3, 5, 59, 1_400));
     check!(hmsm(3, 5, 59, 1_300), TimeDelta::milliseconds(800).unwrap(), hmsm(3, 6, 0, 100));
     check!(hmsm(3, 5, 59, 1_300), TimeDelta::milliseconds(1800).unwrap(), hmsm(3, 6, 1, 100));
-    check!(hmsm(3, 5, 59, 900), TimeDelta::seconds(86399).unwrap(), hmsm(3, 5, 58, 900)); // overwrap
-    check!(hmsm(3, 5, 59, 900), TimeDelta::seconds(-86399).unwrap(), hmsm(3, 6, 0, 900));
+    check!(hmsm(3, 5, 59, 900), TimeDelta::seconds(86399), hmsm(3, 5, 58, 900)); // overwrap
+    check!(hmsm(3, 5, 59, 900), TimeDelta::seconds(-86399), hmsm(3, 6, 0, 900));
     check!(hmsm(3, 5, 59, 900), TimeDelta::days(12345), hmsm(3, 5, 59, 900));
     check!(hmsm(3, 5, 59, 1_300), TimeDelta::days(1), hmsm(3, 5, 59, 300));
     check!(hmsm(3, 5, 59, 1_300), TimeDelta::days(-1), hmsm(3, 6, 0, 300));
@@ -183,11 +183,11 @@ fn test_time_sub() {
 
     check!(hmsm(3, 5, 7, 900), hmsm(3, 5, 7, 900), TimeDelta::zero());
     check!(hmsm(3, 5, 7, 900), hmsm(3, 5, 7, 600), TimeDelta::milliseconds(300).unwrap());
-    check!(hmsm(3, 5, 7, 200), hmsm(2, 4, 6, 200), TimeDelta::seconds(3600 + 60 + 1).unwrap());
+    check!(hmsm(3, 5, 7, 200), hmsm(2, 4, 6, 200), TimeDelta::seconds(3600 + 60 + 1));
     check!(
         hmsm(3, 5, 7, 200),
         hmsm(2, 4, 6, 300),
-        TimeDelta::seconds(3600 + 60).unwrap() + TimeDelta::milliseconds(900).unwrap()
+        TimeDelta::seconds(3600 + 60) + TimeDelta::milliseconds(900).unwrap()
     );
 
     // treats the leap second as if it coincides with the prior non-leap second,
diff --git a/src/time_delta.rs b/src/time_delta.rs
index f354e0630d..f25e9c71fb 100644
--- a/src/time_delta.rs
+++ b/src/time_delta.rs
@@ -126,14 +126,11 @@ impl TimeDelta {
 
     /// Makes a new `TimeDelta` with the given number of seconds.
     ///
-    /// # Errors
-    ///
-    /// Returns `None` when `seconds` is more than `i64::MAX / 1_000` or less than
-    /// `-i64::MAX / 1_000` (in this context, this is the same as `i64::MIN / 1_000` due to
-    /// rounding).
+    /// Use [`TimeDelta::new()`] if you want to create a value `TimeDelta` with a range that is
+    /// greater than that of an `i32`.
     #[inline]
-    pub const fn seconds(seconds: i64) -> Option<TimeDelta> {
-        TimeDelta::new(seconds, 0)
+    pub const fn seconds(seconds: i32) -> TimeDelta {
+        expect!(TimeDelta::new(seconds as i64, 0), "always in range")
     }
 
     /// Makes a new `TimeDelta` with the given number of milliseconds.
@@ -538,7 +535,7 @@ mod tests {
     #[test]
     fn test_duration() {
         let days = TimeDelta::days;
-        let seconds = |s| TimeDelta::seconds(s).unwrap();
+        let seconds = TimeDelta::seconds;
 
         assert!(seconds(1) != TimeDelta::zero());
         assert_eq!(seconds(1) + seconds(2), seconds(3));
@@ -563,10 +560,10 @@ mod tests {
         assert_eq!(TimeDelta::zero().num_days(), 0);
         assert_eq!(TimeDelta::days(1).num_days(), 1);
         assert_eq!(TimeDelta::days(-1).num_days(), -1);
-        assert_eq!(TimeDelta::seconds(86_399).unwrap().num_days(), 0);
-        assert_eq!(TimeDelta::seconds(86_401).unwrap().num_days(), 1);
-        assert_eq!(TimeDelta::seconds(-86_399).unwrap().num_days(), 0);
-        assert_eq!(TimeDelta::seconds(-86_401).unwrap().num_days(), -1);
+        assert_eq!(TimeDelta::seconds(86_399).num_days(), 0);
+        assert_eq!(TimeDelta::seconds(86_401).num_days(), 1);
+        assert_eq!(TimeDelta::seconds(-86_399).num_days(), 0);
+        assert_eq!(TimeDelta::seconds(-86_401).num_days(), -1);
         assert_eq!(TimeDelta::days(i32::MAX).num_days(), i32::MAX as i64);
         assert_eq!(TimeDelta::days(i32::MIN).num_days(), i32::MIN as i64);
     }
@@ -574,44 +571,14 @@ mod tests {
     #[test]
     fn test_duration_num_seconds() {
         assert_eq!(TimeDelta::zero().num_seconds(), 0);
-        assert_eq!(TimeDelta::seconds(1).unwrap().num_seconds(), 1);
-        assert_eq!(TimeDelta::seconds(-1).unwrap().num_seconds(), -1);
+        assert_eq!(TimeDelta::seconds(1).num_seconds(), 1);
+        assert_eq!(TimeDelta::seconds(-1).num_seconds(), -1);
         assert_eq!(TimeDelta::milliseconds(999).unwrap().num_seconds(), 0);
         assert_eq!(TimeDelta::milliseconds(1001).unwrap().num_seconds(), 1);
         assert_eq!(TimeDelta::milliseconds(-999).unwrap().num_seconds(), 0);
         assert_eq!(TimeDelta::milliseconds(-1001).unwrap().num_seconds(), -1);
     }
 
-    #[test]
-    fn test_duration_seconds_max_allowed() {
-        let duration = TimeDelta::seconds(i64::MAX / 1_000).unwrap();
-        assert_eq!(duration.num_seconds(), i64::MAX / 1_000);
-        assert_eq!(
-            duration.secs as i128 * 1_000_000_000 + duration.nanos as i128,
-            i64::MAX as i128 / 1_000 * 1_000_000_000
-        );
-    }
-
-    #[test]
-    fn test_duration_seconds_max_overflow() {
-        assert!(TimeDelta::seconds(i64::MAX / 1_000 + 1).is_none());
-    }
-
-    #[test]
-    fn test_duration_seconds_min_allowed() {
-        let duration = TimeDelta::seconds(i64::MIN / 1_000).unwrap(); // Same as -i64::MAX / 1_000 due to rounding
-        assert_eq!(duration.num_seconds(), i64::MIN / 1_000); // Same as -i64::MAX / 1_000 due to rounding
-        assert_eq!(
-            duration.secs as i128 * 1_000_000_000 + duration.nanos as i128,
-            -i64::MAX as i128 / 1_000 * 1_000_000_000
-        );
-    }
-
-    #[test]
-    fn test_duration_seconds_min_underflow() {
-        assert!(TimeDelta::seconds(-i64::MAX / 1_000 - 1).is_none());
-    }
-
     #[test]
     fn test_duration_num_milliseconds() {
         assert_eq!(TimeDelta::zero().num_milliseconds(), 0);
@@ -945,19 +912,19 @@ mod tests {
         assert_eq!(TimeDelta::zero() * i32::MIN, TimeDelta::zero());
         assert_eq!(TimeDelta::nanoseconds(1) * 0, TimeDelta::zero());
         assert_eq!(TimeDelta::nanoseconds(1) * 1, TimeDelta::nanoseconds(1));
-        assert_eq!(TimeDelta::nanoseconds(1) * 1_000_000_000, TimeDelta::seconds(1).unwrap());
-        assert_eq!(TimeDelta::nanoseconds(1) * -1_000_000_000, -TimeDelta::seconds(1).unwrap());
-        assert_eq!(-TimeDelta::nanoseconds(1) * 1_000_000_000, -TimeDelta::seconds(1).unwrap());
+        assert_eq!(TimeDelta::nanoseconds(1) * 1_000_000_000, TimeDelta::seconds(1));
+        assert_eq!(TimeDelta::nanoseconds(1) * -1_000_000_000, -TimeDelta::seconds(1));
+        assert_eq!(-TimeDelta::nanoseconds(1) * 1_000_000_000, -TimeDelta::seconds(1));
         assert_eq!(
             TimeDelta::nanoseconds(30) * 333_333_333,
-            TimeDelta::seconds(10).unwrap() - TimeDelta::nanoseconds(10)
+            TimeDelta::seconds(10) - TimeDelta::nanoseconds(10)
         );
         assert_eq!(
-            (TimeDelta::nanoseconds(1) + TimeDelta::seconds(1).unwrap() + TimeDelta::days(1)) * 3,
-            TimeDelta::nanoseconds(3) + TimeDelta::seconds(3).unwrap() + TimeDelta::days(3)
+            (TimeDelta::nanoseconds(1) + TimeDelta::seconds(1) + TimeDelta::days(1)) * 3,
+            TimeDelta::nanoseconds(3) + TimeDelta::seconds(3) + TimeDelta::days(3)
         );
-        assert_eq!(TimeDelta::milliseconds(1500).unwrap() * -2, TimeDelta::seconds(-3).unwrap());
-        assert_eq!(TimeDelta::milliseconds(-1500).unwrap() * 2, TimeDelta::seconds(-3).unwrap());
+        assert_eq!(TimeDelta::milliseconds(1500).unwrap() * -2, TimeDelta::seconds(-3));
+        assert_eq!(TimeDelta::milliseconds(-1500).unwrap() * 2, TimeDelta::seconds(-3));
     }
 
     #[test]
@@ -968,38 +935,38 @@ mod tests {
         assert_eq!(TimeDelta::nanoseconds(123_456_789) / -1, -TimeDelta::nanoseconds(123_456_789));
         assert_eq!(-TimeDelta::nanoseconds(123_456_789) / -1, TimeDelta::nanoseconds(123_456_789));
         assert_eq!(-TimeDelta::nanoseconds(123_456_789) / 1, -TimeDelta::nanoseconds(123_456_789));
-        assert_eq!(TimeDelta::seconds(1).unwrap() / 3, TimeDelta::nanoseconds(333_333_333));
-        assert_eq!(TimeDelta::seconds(4).unwrap() / 3, TimeDelta::nanoseconds(1_333_333_333));
-        assert_eq!(TimeDelta::seconds(-1).unwrap() / 2, TimeDelta::milliseconds(-500).unwrap());
-        assert_eq!(TimeDelta::seconds(1).unwrap() / -2, TimeDelta::milliseconds(-500).unwrap());
-        assert_eq!(TimeDelta::seconds(-1).unwrap() / -2, TimeDelta::milliseconds(500).unwrap());
-        assert_eq!(TimeDelta::seconds(-4).unwrap() / 3, TimeDelta::nanoseconds(-1_333_333_333));
-        assert_eq!(TimeDelta::seconds(-4).unwrap() / -3, TimeDelta::nanoseconds(1_333_333_333));
+        assert_eq!(TimeDelta::seconds(1) / 3, TimeDelta::nanoseconds(333_333_333));
+        assert_eq!(TimeDelta::seconds(4) / 3, TimeDelta::nanoseconds(1_333_333_333));
+        assert_eq!(TimeDelta::seconds(-1) / 2, TimeDelta::milliseconds(-500).unwrap());
+        assert_eq!(TimeDelta::seconds(1) / -2, TimeDelta::milliseconds(-500).unwrap());
+        assert_eq!(TimeDelta::seconds(-1) / -2, TimeDelta::milliseconds(500).unwrap());
+        assert_eq!(TimeDelta::seconds(-4) / 3, TimeDelta::nanoseconds(-1_333_333_333));
+        assert_eq!(TimeDelta::seconds(-4) / -3, TimeDelta::nanoseconds(1_333_333_333));
     }
 
     #[test]
     fn test_duration_sum() {
-        let duration_list_1 = [TimeDelta::zero(), TimeDelta::seconds(1).unwrap()];
+        let duration_list_1 = [TimeDelta::zero(), TimeDelta::seconds(1)];
         let sum_1: TimeDelta = duration_list_1.iter().sum();
-        assert_eq!(sum_1, TimeDelta::seconds(1).unwrap());
+        assert_eq!(sum_1, TimeDelta::seconds(1));
 
         let duration_list_2 = [
             TimeDelta::zero(),
-            TimeDelta::seconds(1).unwrap(),
-            TimeDelta::seconds(6).unwrap(),
-            TimeDelta::seconds(10).unwrap(),
+            TimeDelta::seconds(1),
+            TimeDelta::seconds(6),
+            TimeDelta::seconds(10),
         ];
         let sum_2: TimeDelta = duration_list_2.iter().sum();
-        assert_eq!(sum_2, TimeDelta::seconds(17).unwrap());
+        assert_eq!(sum_2, TimeDelta::seconds(17));
 
         let duration_arr = [
             TimeDelta::zero(),
-            TimeDelta::seconds(1).unwrap(),
-            TimeDelta::seconds(6).unwrap(),
-            TimeDelta::seconds(10).unwrap(),
+            TimeDelta::seconds(1),
+            TimeDelta::seconds(6),
+            TimeDelta::seconds(10),
         ];
         let sum_3: TimeDelta = duration_arr.into_iter().sum();
-        assert_eq!(sum_3, TimeDelta::seconds(17).unwrap());
+        assert_eq!(sum_3, TimeDelta::seconds(17));
     }
 
     #[test]
@@ -1007,7 +974,7 @@ mod tests {
         assert_eq!(TimeDelta::zero().to_string(), "P0D");
         assert_eq!(TimeDelta::days(42).to_string(), "PT3628800S");
         assert_eq!(TimeDelta::days(-42).to_string(), "-PT3628800S");
-        assert_eq!(TimeDelta::seconds(42).unwrap().to_string(), "PT42S");
+        assert_eq!(TimeDelta::seconds(42).to_string(), "PT42S");
         assert_eq!(TimeDelta::milliseconds(42).unwrap().to_string(), "PT0.042S");
         assert_eq!(TimeDelta::microseconds(42).to_string(), "PT0.000042S");
         assert_eq!(TimeDelta::nanoseconds(42).to_string(), "PT0.000000042S");
@@ -1015,7 +982,7 @@ mod tests {
             (TimeDelta::days(7) + TimeDelta::milliseconds(6543).unwrap()).to_string(),
             "PT604806.543S"
         );
-        assert_eq!(TimeDelta::seconds(-86_401).unwrap().to_string(), "-PT86401S");
+        assert_eq!(TimeDelta::seconds(-86_401).to_string(), "-PT86401S");
         assert_eq!(TimeDelta::nanoseconds(-1).to_string(), "-PT0.000000001S");
 
         // the format specifier should have no effect on `TimeDelta`
@@ -1027,8 +994,8 @@ mod tests {
 
     #[test]
     fn test_to_std() {
-        assert_eq!(TimeDelta::seconds(1).unwrap().to_std(), Ok(Duration::new(1, 0)));
-        assert_eq!(TimeDelta::seconds(86_401).unwrap().to_std(), Ok(Duration::new(86_401, 0)));
+        assert_eq!(TimeDelta::seconds(1).to_std(), Ok(Duration::new(1, 0)));
+        assert_eq!(TimeDelta::seconds(86_401).to_std(), Ok(Duration::new(86_401, 0)));
         assert_eq!(
             TimeDelta::milliseconds(123).unwrap().to_std(),
             Ok(Duration::new(0, 123_000_000))
@@ -1039,17 +1006,14 @@ mod tests {
         );
         assert_eq!(TimeDelta::nanoseconds(777).to_std(), Ok(Duration::new(0, 777)));
         assert_eq!(MAX.to_std(), Ok(Duration::new(9_223_372_036_854_775, 807_000_000)));
-        assert_eq!(TimeDelta::seconds(-1).unwrap().to_std(), Err(OutOfRangeError(())));
+        assert_eq!(TimeDelta::seconds(-1).to_std(), Err(OutOfRangeError(())));
         assert_eq!(TimeDelta::milliseconds(-1).unwrap().to_std(), Err(OutOfRangeError(())));
     }
 
     #[test]
     fn test_from_std() {
-        assert_eq!(Ok(TimeDelta::seconds(1).unwrap()), TimeDelta::from_std(Duration::new(1, 0)));
-        assert_eq!(
-            Ok(TimeDelta::seconds(86_401).unwrap()),
-            TimeDelta::from_std(Duration::new(86_401, 0))
-        );
+        assert_eq!(Ok(TimeDelta::seconds(1)), TimeDelta::from_std(Duration::new(1, 0)));
+        assert_eq!(Ok(TimeDelta::seconds(86_401)), TimeDelta::from_std(Duration::new(86_401, 0)));
         assert_eq!(
             Ok(TimeDelta::milliseconds(123).unwrap()),
             TimeDelta::from_std(Duration::new(0, 123_000_000))
@@ -1076,7 +1040,7 @@ mod tests {
         const ONE_DAY: TimeDelta = TimeDelta::days(1);
         const ONE_HOUR: TimeDelta = TimeDelta::hours(1);
         const ONE_MINUTE: TimeDelta = TimeDelta::minutes(1);
-        const ONE_SECOND: TimeDelta = expect!(TimeDelta::seconds(1), "");
+        const ONE_SECOND: TimeDelta = TimeDelta::seconds(1);
         const ONE_MILLI: TimeDelta = expect!(TimeDelta::milliseconds(1), "");
         const ONE_MICRO: TimeDelta = TimeDelta::microseconds(1);
         const ONE_NANO: TimeDelta = TimeDelta::nanoseconds(1);
@@ -1099,7 +1063,7 @@ mod tests {
         assert!(ONE_NANO != TimeDelta::zero());
         assert_eq!(
             combo,
-            TimeDelta::seconds(86400 * 7 + 86400 + 3600 + 60 + 1).unwrap()
+            TimeDelta::seconds(86400 * 7 + 86400 + 3600 + 60 + 1)
                 + TimeDelta::nanoseconds(1 + 1_000 + 1_000_000)
         );
     }
@@ -1107,7 +1071,7 @@ mod tests {
     #[test]
     #[cfg(feature = "rkyv-validation")]
     fn test_rkyv_validation() {
-        let duration = TimeDelta::seconds(1).unwrap();
+        let duration = TimeDelta::seconds(1);
         let bytes = rkyv::to_bytes::<_, 16>(&duration).unwrap();
         assert_eq!(rkyv::from_bytes::<TimeDelta>(&bytes).unwrap(), duration);
     }