diff --git a/src/timing/formatter/complete.rs b/src/timing/formatter/complete.rs
index 7fdb11bd..3354bbea 100644
--- a/src/timing/formatter/complete.rs
+++ b/src/timing/formatter/complete.rs
@@ -52,7 +52,7 @@ impl Display for Inner {
                 // Since, this Formatter is used for writing out split files, we
                 // have to use an ASCII Minus here.
                 f.write_str(ASCII_MINUS)?;
-                ((-total_seconds) as u64, (-nanoseconds) as u32)
+                (total_seconds.wrapping_neg() as u64, (-nanoseconds) as u32)
             } else {
                 (total_seconds as u64, nanoseconds as u32)
             };
@@ -86,3 +86,113 @@ impl Display for Inner {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use core::str::FromStr;
+
+    use super::*;
+
+    #[test]
+    fn min() {
+        // This verifies that flipping the sign of the minimum value doesn't
+        // cause a panic.
+        let time = TimeSpan::from(crate::platform::Duration::MIN);
+        let inner = Complete.format(Some(time));
+        assert_eq!(inner.to_string(), "-106751991167300.15:30:08.999999999");
+    }
+
+    #[test]
+    fn max() {
+        let time = TimeSpan::from(crate::platform::Duration::MAX);
+        let inner = Complete.format(Some(time));
+        assert_eq!(inner.to_string(), "106751991167300.15:30:07.999999999");
+    }
+
+    #[test]
+    fn zero() {
+        let time = TimeSpan::zero();
+        let inner = Complete.format(Some(time));
+        assert_eq!(inner.to_string(), "00:00:00.000000000");
+    }
+
+    #[test]
+    fn empty() {
+        let inner = Complete.format(None);
+        assert_eq!(inner.to_string(), "00:00:00.000000000");
+    }
+
+    #[test]
+    fn slightly_positive() {
+        let time = TimeSpan::from_str("0.000000001").unwrap();
+        let inner = Complete.format(Some(time));
+        assert_eq!(inner.to_string(), "00:00:00.000000001");
+
+        assert_eq!(
+            Complete.format(TimeSpan::from_seconds(0.5)).to_string(),
+            "00:00:00.500000000"
+        );
+        assert_eq!(
+            Complete.format(TimeSpan::from_seconds(1.5)).to_string(),
+            "00:00:01.500000000"
+        );
+    }
+
+    #[test]
+    fn slightly_negative() {
+        let time = TimeSpan::from_str("-0.000000001").unwrap();
+        let inner = Complete.format(Some(time));
+        assert_eq!(inner.to_string(), "-00:00:00.000000001");
+
+        assert_eq!(
+            Complete.format(TimeSpan::from_seconds(-1.5)).to_string(),
+            "-00:00:01.500000000"
+        );
+        assert_eq!(
+            Complete.format(TimeSpan::from_seconds(-0.5)).to_string(),
+            "-00:00:00.500000000"
+        );
+    }
+
+    #[test]
+    fn seconds() {
+        let time = TimeSpan::from_str("23.1234").unwrap();
+        let inner = Complete.format(Some(time));
+        assert_eq!(inner.to_string(), "00:00:23.123400000");
+    }
+
+    #[test]
+    fn minutes() {
+        let time = TimeSpan::from_str("12:34.987654321").unwrap();
+        let inner = Complete.format(Some(time));
+        assert_eq!(inner.to_string(), "00:12:34.987654321");
+    }
+
+    #[test]
+    fn hours() {
+        let time = TimeSpan::from_str("12:34:56.123456789").unwrap();
+        let inner = Complete.format(Some(time));
+        assert_eq!(inner.to_string(), "12:34:56.123456789");
+    }
+
+    #[test]
+    fn negative() {
+        let time = TimeSpan::from_str("-12:34:56.123456789").unwrap();
+        let inner = Complete.format(Some(time));
+        assert_eq!(inner.to_string(), "-12:34:56.123456789");
+    }
+
+    #[test]
+    fn days() {
+        let time = TimeSpan::from_str("2148:34:56.123456789").unwrap();
+        let inner = Complete.format(Some(time));
+        assert_eq!(inner.to_string(), "89.12:34:56.123456789");
+    }
+
+    #[test]
+    fn negative_days() {
+        let time = TimeSpan::from_str("-2148:34:56.123456789").unwrap();
+        let inner = Complete.format(Some(time));
+        assert_eq!(inner.to_string(), "-89.12:34:56.123456789");
+    }
+}
diff --git a/src/timing/formatter/days.rs b/src/timing/formatter/days.rs
index a2d54aed..577eb20d 100644
--- a/src/timing/formatter/days.rs
+++ b/src/timing/formatter/days.rs
@@ -48,7 +48,7 @@ impl Display for Inner {
             let (total_seconds, nanoseconds) = time.to_seconds_and_subsec_nanoseconds();
             let total_seconds = if (total_seconds | nanoseconds as i64) < 0 {
                 f.write_str(MINUS)?;
-                (-total_seconds) as u64
+                total_seconds.wrapping_neg() as u64
             } else {
                 total_seconds as u64
             };
@@ -82,3 +82,107 @@ impl Display for Inner {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use core::str::FromStr;
+
+    use super::*;
+
+    #[test]
+    fn min() {
+        // This verifies that flipping the sign of the minimum value doesn't
+        // cause a panic.
+        let time = TimeSpan::from(crate::platform::Duration::MIN);
+        let inner = Days.format(Some(time));
+        assert_eq!(inner.to_string(), "−106751991167300d 15:30:08");
+    }
+
+    #[test]
+    fn max() {
+        let time = TimeSpan::from(crate::platform::Duration::MAX);
+        let inner = Days.format(Some(time));
+        assert_eq!(inner.to_string(), "106751991167300d 15:30:07");
+    }
+
+    #[test]
+    fn zero() {
+        let time = TimeSpan::zero();
+        let inner = Days.format(Some(time));
+        assert_eq!(inner.to_string(), "0:00");
+    }
+
+    #[test]
+    fn empty() {
+        let inner = Days.format(None);
+        assert_eq!(inner.to_string(), "0:00");
+    }
+
+    #[test]
+    fn slightly_positive() {
+        let time = TimeSpan::from_str("0.000000001").unwrap();
+        let inner = Days.format(Some(time));
+        assert_eq!(inner.to_string(), "0:00");
+
+        assert_eq!(Days.format(TimeSpan::from_seconds(0.5)).to_string(), "0:00");
+        assert_eq!(Days.format(TimeSpan::from_seconds(1.5)).to_string(), "0:01");
+    }
+
+    #[test]
+    fn slightly_negative() {
+        let time = TimeSpan::from_str("-0.000000001").unwrap();
+        let inner = Days.format(Some(time));
+        assert_eq!(inner.to_string(), "−0:00");
+
+        assert_eq!(
+            Days.format(TimeSpan::from_seconds(-1.5)).to_string(),
+            "−0:01"
+        );
+        assert_eq!(
+            Days.format(TimeSpan::from_seconds(-0.5)).to_string(),
+            "−0:00"
+        );
+    }
+
+    #[test]
+    fn seconds() {
+        let time = TimeSpan::from_str("23.1234").unwrap();
+        let inner = Days.format(Some(time));
+        assert_eq!(inner.to_string(), "0:23");
+    }
+
+    #[test]
+    fn minutes() {
+        let time = TimeSpan::from_str("12:34.987654321").unwrap();
+        let inner = Days.format(Some(time));
+        assert_eq!(inner.to_string(), "12:34");
+    }
+
+    #[test]
+    fn hours() {
+        let time = TimeSpan::from_str("12:34:56.123456789").unwrap();
+        let inner = Days.format(Some(time));
+        assert_eq!(inner.to_string(), "12:34:56");
+    }
+
+    #[test]
+    fn negative() {
+        let time = TimeSpan::from_str("-12:34:56.123456789").unwrap();
+        let inner = Days.format(Some(time));
+        assert_eq!(inner.to_string(), "−12:34:56");
+    }
+
+    #[test]
+    fn days() {
+        let time = TimeSpan::from_str("2148:34:56.123456789").unwrap();
+        let inner = Days.format(Some(time));
+        assert_eq!(inner.to_string(), "89d 12:34:56");
+    }
+
+    #[test]
+    fn negative_days() {
+        let time = TimeSpan::from_str("-2148:34:56.123456789").unwrap();
+        let inner = Days.format(Some(time));
+        assert_eq!(inner.to_string(), "−89d 12:34:56");
+    }
+}
diff --git a/src/timing/formatter/delta.rs b/src/timing/formatter/delta.rs
index 9dbb8825..3a35128c 100644
--- a/src/timing/formatter/delta.rs
+++ b/src/timing/formatter/delta.rs
@@ -48,6 +48,12 @@ impl Delta {
     pub const fn with_decimal_dropping() -> Self {
         Delta(true, Accuracy::Tenths)
     }
+
+    /// Creates a new Delta Time Formatter that does not drop the fractional
+    /// part and uses tenths when showing the fractional part.
+    pub const fn without_decimal_dropping() -> Self {
+        Delta(false, Accuracy::Tenths)
+    }
 }
 
 impl Default for Delta {
@@ -78,7 +84,7 @@ impl Display for Inner {
             let bit_or = total_seconds | nanoseconds as i64;
             let (total_seconds, nanoseconds) = if bit_or < 0 {
                 f.write_str(MINUS)?;
-                ((-total_seconds) as u64, (-nanoseconds) as u32)
+                (total_seconds.wrapping_neg() as u64, (-nanoseconds) as u32)
             } else {
                 if bit_or > 0 {
                     f.write_str(PLUS)?;
@@ -122,10 +128,61 @@ impl Display for Inner {
 
 #[cfg(test)]
 mod tests {
+    use core::str::FromStr;
+
     use super::*;
 
     #[test]
-    fn sign_works() {
+    fn min() {
+        // This verifies that flipping the sign of the minimum value doesn't
+        // cause a panic.
+        let time = TimeSpan::from(crate::platform::Duration::MIN);
+        let inner = Delta::new().format(Some(time));
+        assert_eq!(inner.to_string(), "−2562047788015215:30:08");
+    }
+
+    #[test]
+    fn max() {
+        let time = TimeSpan::from(crate::platform::Duration::MAX);
+        let inner = Delta::new().format(Some(time));
+        assert_eq!(inner.to_string(), "+2562047788015215:30:07");
+    }
+
+    #[test]
+    fn zero() {
+        let time = TimeSpan::zero();
+        let inner = Delta::new().format(Some(time));
+        assert_eq!(inner.to_string(), "0.0");
+    }
+
+    #[test]
+    fn empty() {
+        let inner = Delta::new().format(None);
+        assert_eq!(inner.to_string(), "—");
+    }
+
+    #[test]
+    fn slightly_positive() {
+        let time = TimeSpan::from_str("0.000000001").unwrap();
+        let inner = Delta::new().format(Some(time));
+        assert_eq!(inner.to_string(), "+0.0");
+
+        assert_eq!(
+            Delta::new().format(TimeSpan::from_seconds(0.5)).to_string(),
+            "+0.5"
+        );
+        assert_eq!(
+            Delta::new().format(TimeSpan::from_seconds(1.5)).to_string(),
+            "+1.5"
+        );
+    }
+
+    #[test]
+    fn slightly_negative() {
+        let time = TimeSpan::from_str("-0.000000001").unwrap();
+        let inner = Delta::new().format(Some(time));
+        assert_eq!(inner.to_string(), "−0.0");
+
         assert_eq!(
             Delta::new()
                 .format(TimeSpan::from_seconds(-1.5))
@@ -138,17 +195,61 @@ mod tests {
                 .to_string(),
             "−0.5"
         );
+    }
 
-        // We drop the sign entirely when it's exactly 0.
-        assert_eq!(Delta::new().format(TimeSpan::zero()).to_string(), "0.0");
+    #[test]
+    fn seconds() {
+        let time = TimeSpan::from_str("23.1234").unwrap();
+        let inner = Delta::new().format(Some(time));
+        assert_eq!(inner.to_string(), "+23.1");
+    }
 
-        assert_eq!(
-            Delta::new().format(TimeSpan::from_seconds(0.5)).to_string(),
-            "+0.5"
-        );
-        assert_eq!(
-            Delta::new().format(TimeSpan::from_seconds(1.5)).to_string(),
-            "+1.5"
-        );
+    #[test]
+    fn minutes_with_decimal_dropping() {
+        let time = TimeSpan::from_str("12:34.987654321").unwrap();
+        let inner = Delta::with_decimal_dropping().format(Some(time));
+        assert_eq!(inner.to_string(), "+12:34");
+    }
+
+    #[test]
+    fn minutes_without_decimal_dropping() {
+        let time = TimeSpan::from_str("12:34.987654321").unwrap();
+        let inner = Delta::without_decimal_dropping().format(Some(time));
+        assert_eq!(inner.to_string(), "+12:34.9");
+    }
+
+    #[test]
+    fn hours_with_decimal_dropping() {
+        let time = TimeSpan::from_str("12:34:56.123456789").unwrap();
+        let inner = Delta::with_decimal_dropping().format(Some(time));
+        assert_eq!(inner.to_string(), "+12:34:56");
+    }
+
+    #[test]
+    fn hours_without_decimal_dropping() {
+        let time = TimeSpan::from_str("12:34:56.123456789").unwrap();
+        let inner = Delta::without_decimal_dropping().format(Some(time));
+        assert_eq!(inner.to_string(), "+12:34:56.1");
+    }
+
+    #[test]
+    fn negative() {
+        let time = TimeSpan::from_str("-12:34:56.123456789").unwrap();
+        let inner = Delta::new().format(Some(time));
+        assert_eq!(inner.to_string(), "−12:34:56");
+    }
+
+    #[test]
+    fn days() {
+        let time = TimeSpan::from_str("2148:34:56.123456789").unwrap();
+        let inner = Delta::new().format(Some(time));
+        assert_eq!(inner.to_string(), "+2148:34:56");
+    }
+
+    #[test]
+    fn negative_days() {
+        let time = TimeSpan::from_str("-2148:34:56.123456789").unwrap();
+        let inner = Delta::new().format(Some(time));
+        assert_eq!(inner.to_string(), "−2148:34:56");
     }
 }
diff --git a/src/timing/formatter/regular.rs b/src/timing/formatter/regular.rs
index 7c264a26..3fdda353 100644
--- a/src/timing/formatter/regular.rs
+++ b/src/timing/formatter/regular.rs
@@ -70,7 +70,7 @@ impl Display for Inner {
             let (total_seconds, nanoseconds) = time.to_seconds_and_subsec_nanoseconds();
             let (total_seconds, nanoseconds) = if (total_seconds | nanoseconds as i64) < 0 {
                 f.write_str(MINUS)?;
-                ((-total_seconds) as u64, (-nanoseconds) as u32)
+                (total_seconds.wrapping_neg() as u64, (-nanoseconds) as u32)
             } else {
                 (total_seconds as u64, nanoseconds as u32)
             };
@@ -99,3 +99,142 @@ impl Display for Inner {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use core::str::FromStr;
+
+    use super::*;
+
+    #[test]
+    fn min() {
+        // This verifies that flipping the sign of the minimum value doesn't
+        // cause a panic.
+        let time = TimeSpan::from(crate::platform::Duration::MIN);
+        let inner = Regular::new().format(Some(time));
+        assert_eq!(inner.to_string(), "−2562047788015215:30:08");
+    }
+
+    #[test]
+    fn max() {
+        let time = TimeSpan::from(crate::platform::Duration::MAX);
+        let inner = Regular::new().format(Some(time));
+        assert_eq!(inner.to_string(), "2562047788015215:30:07");
+    }
+
+    #[test]
+    fn zero() {
+        let time = TimeSpan::zero();
+        let inner = Regular::new().format(Some(time));
+        assert_eq!(inner.to_string(), "0:00");
+    }
+
+    #[test]
+    fn empty() {
+        let inner = Regular::new().format(None);
+        assert_eq!(inner.to_string(), "—");
+    }
+
+    #[test]
+    fn slightly_positive() {
+        let time = TimeSpan::from_str("0.000000001").unwrap();
+        let inner = Regular::new().format(Some(time));
+        assert_eq!(inner.to_string(), "0:00");
+
+        assert_eq!(
+            Regular::new()
+                .format(TimeSpan::from_seconds(0.5))
+                .to_string(),
+            "0:00"
+        );
+        assert_eq!(
+            Regular::new()
+                .format(TimeSpan::from_seconds(1.5))
+                .to_string(),
+            "0:01"
+        );
+    }
+
+    #[test]
+    fn slightly_negative() {
+        let time = TimeSpan::from_str("-0.000000001").unwrap();
+        let inner = Regular::new().format(Some(time));
+        assert_eq!(inner.to_string(), "−0:00");
+
+        assert_eq!(
+            Regular::new()
+                .format(TimeSpan::from_seconds(-1.5))
+                .to_string(),
+            "−0:01"
+        );
+        assert_eq!(
+            Regular::new()
+                .format(TimeSpan::from_seconds(-0.5))
+                .to_string(),
+            "−0:00"
+        );
+    }
+
+    #[test]
+    fn seconds() {
+        let time = TimeSpan::from_str("23.1234").unwrap();
+        let inner = Regular::new().format(Some(time));
+        assert_eq!(inner.to_string(), "0:23");
+    }
+
+    #[test]
+    fn minutes() {
+        let time = TimeSpan::from_str("12:34.987654321").unwrap();
+        let inner = Regular::new().format(Some(time));
+        assert_eq!(inner.to_string(), "12:34");
+    }
+
+    #[test]
+    fn hours() {
+        let time = TimeSpan::from_str("12:34:56.123456789").unwrap();
+        let inner = Regular::new().format(Some(time));
+        assert_eq!(inner.to_string(), "12:34:56");
+    }
+
+    #[test]
+    fn seconds_with_hundredths() {
+        let time = TimeSpan::from_str("23.1234").unwrap();
+        let inner = Regular::with_accuracy(Accuracy::Hundredths).format(Some(time));
+        assert_eq!(inner.to_string(), "0:23.12");
+    }
+
+    #[test]
+    fn minutes_with_hundredths() {
+        let time = TimeSpan::from_str("12:34.987654321").unwrap();
+        let inner = Regular::with_accuracy(Accuracy::Hundredths).format(Some(time));
+        assert_eq!(inner.to_string(), "12:34.98");
+    }
+
+    #[test]
+    fn hours_with_hundredths() {
+        let time = TimeSpan::from_str("12:34:56.123456789").unwrap();
+        let inner = Regular::with_accuracy(Accuracy::Hundredths).format(Some(time));
+        assert_eq!(inner.to_string(), "12:34:56.12");
+    }
+
+    #[test]
+    fn negative() {
+        let time = TimeSpan::from_str("-12:34:56.123456789").unwrap();
+        let inner = Regular::new().format(Some(time));
+        assert_eq!(inner.to_string(), "−12:34:56");
+    }
+
+    #[test]
+    fn days() {
+        let time = TimeSpan::from_str("2148:34:56.123456789").unwrap();
+        let inner = Regular::new().format(Some(time));
+        assert_eq!(inner.to_string(), "2148:34:56");
+    }
+
+    #[test]
+    fn negative_days() {
+        let time = TimeSpan::from_str("-2148:34:56.123456789").unwrap();
+        let inner = Regular::new().format(Some(time));
+        assert_eq!(inner.to_string(), "−2148:34:56");
+    }
+}
diff --git a/src/timing/formatter/segment_time.rs b/src/timing/formatter/segment_time.rs
index 88eb46c5..f5bc1827 100644
--- a/src/timing/formatter/segment_time.rs
+++ b/src/timing/formatter/segment_time.rs
@@ -71,7 +71,7 @@ impl Display for Inner {
             let (total_seconds, nanoseconds) = time.to_seconds_and_subsec_nanoseconds();
             let (total_seconds, nanoseconds) = if (total_seconds | nanoseconds as i64) < 0 {
                 f.write_str(MINUS)?;
-                ((-total_seconds) as u64, (-nanoseconds) as u32)
+                (total_seconds.wrapping_neg() as u64, (-nanoseconds) as u32)
             } else {
                 (total_seconds as u64, nanoseconds as u32)
             };
@@ -105,9 +105,120 @@ impl Display for Inner {
     }
 }
 
-#[test]
-fn test() {
-    let time = "4:20.69".parse::<TimeSpan>().unwrap();
-    let formatted = SegmentTime::new().format(time).to_string();
-    assert_eq!(formatted, "4:20.69");
+#[cfg(test)]
+mod tests {
+    use core::str::FromStr;
+
+    use super::*;
+
+    #[test]
+    fn min() {
+        // This verifies that flipping the sign of the minimum value doesn't
+        // cause a panic.
+        let time = TimeSpan::from(crate::platform::Duration::MIN);
+        let inner = SegmentTime::new().format(Some(time));
+        assert_eq!(inner.to_string(), "−2562047788015215:30:08.99");
+    }
+
+    #[test]
+    fn max() {
+        let time = TimeSpan::from(crate::platform::Duration::MAX);
+        let inner = SegmentTime::new().format(Some(time));
+        assert_eq!(inner.to_string(), "2562047788015215:30:07.99");
+    }
+
+    #[test]
+    fn zero() {
+        let time = TimeSpan::zero();
+        let inner = SegmentTime::new().format(Some(time));
+        assert_eq!(inner.to_string(), "0.00");
+    }
+
+    #[test]
+    fn empty() {
+        let inner = SegmentTime::new().format(None);
+        assert_eq!(inner.to_string(), "—");
+    }
+
+    #[test]
+    fn slightly_positive() {
+        let time = TimeSpan::from_str("0.000000001").unwrap();
+        let inner = SegmentTime::new().format(Some(time));
+        assert_eq!(inner.to_string(), "0.00");
+
+        assert_eq!(
+            SegmentTime::new()
+                .format(TimeSpan::from_seconds(0.5))
+                .to_string(),
+            "0.50"
+        );
+        assert_eq!(
+            SegmentTime::new()
+                .format(TimeSpan::from_seconds(1.5))
+                .to_string(),
+            "1.50"
+        );
+    }
+
+    #[test]
+    fn slightly_negative() {
+        let time = TimeSpan::from_str("-0.000000001").unwrap();
+        let inner = SegmentTime::new().format(Some(time));
+        assert_eq!(inner.to_string(), "−0.00");
+
+        assert_eq!(
+            SegmentTime::new()
+                .format(TimeSpan::from_seconds(-1.5))
+                .to_string(),
+            "−1.50"
+        );
+        assert_eq!(
+            SegmentTime::new()
+                .format(TimeSpan::from_seconds(-0.5))
+                .to_string(),
+            "−0.50"
+        );
+    }
+
+    #[test]
+    fn seconds() {
+        let time = TimeSpan::from_str("23.1234").unwrap();
+        let inner = SegmentTime::new().format(Some(time));
+        assert_eq!(inner.to_string(), "23.12");
+    }
+
+    #[test]
+    fn minutes() {
+        let time = TimeSpan::from_str("12:34.987654321").unwrap();
+        let inner = SegmentTime::new().format(Some(time));
+        assert_eq!(inner.to_string(), "12:34.98");
+    }
+
+    #[test]
+    fn hours() {
+        let time = TimeSpan::from_str("12:34:56.123456789").unwrap();
+        let inner = SegmentTime::new().format(Some(time));
+        assert_eq!(inner.to_string(), "12:34:56.12");
+    }
+
+    #[test]
+    fn negative() {
+        let time = TimeSpan::from_str("-12:34:56.123456789").unwrap();
+        let inner = SegmentTime::new().format(Some(time));
+        assert_eq!(inner.to_string(), "−12:34:56.12");
+    }
+
+    #[test]
+    fn days() {
+        let time = TimeSpan::from_str("2148:34:56.123456789").unwrap();
+        let inner = SegmentTime::new().format(Some(time));
+        assert_eq!(inner.to_string(), "2148:34:56.12");
+    }
+
+    #[test]
+    fn negative_days() {
+        let time = TimeSpan::from_str("-2148:34:56.123456789").unwrap();
+        let inner = SegmentTime::new().format(Some(time));
+        assert_eq!(inner.to_string(), "−2148:34:56.12");
+    }
 }
diff --git a/src/timing/formatter/timer.rs b/src/timing/formatter/timer.rs
index 9b27847d..29b7e925 100644
--- a/src/timing/formatter/timer.rs
+++ b/src/timing/formatter/timer.rs
@@ -72,7 +72,7 @@ impl Display for TimeInner {
             let (total_seconds, nanoseconds) = time.to_seconds_and_subsec_nanoseconds();
             let total_seconds = if (total_seconds | nanoseconds as i64) < 0 {
                 f.write_str(MINUS)?;
-                (-total_seconds) as u64
+                total_seconds.wrapping_neg() as u64
             } else {
                 total_seconds as u64
             };
@@ -189,8 +189,177 @@ impl Display for FractionInner {
     }
 }
 
-#[test]
-fn test() {
-    let time = "4:20.999999".parse::<TimeSpan>().unwrap();
-    assert_eq!(Fraction::new().format(Some(time)).to_string(), ".99");
+#[cfg(test)]
+mod tests {
+    use core::str::FromStr;
+
+    use super::*;
+
+    #[test]
+    fn min() {
+        // This verifies that flipping the sign of the minimum value doesn't
+        // cause a panic.
+        let time = TimeSpan::from(crate::platform::Duration::MIN);
+        let inner = Time::new().format(Some(time));
+        assert_eq!(inner.to_string(), "−2562047788015215:30:08");
+        let inner = Fraction::new().format(Some(time));
+        assert_eq!(inner.to_string(), ".99");
+    }
+
+    #[test]
+    fn max() {
+        let time = TimeSpan::from(crate::platform::Duration::MAX);
+        let inner = Time::new().format(Some(time));
+        assert_eq!(inner.to_string(), "2562047788015215:30:07");
+        let inner = Fraction::new().format(Some(time));
+        assert_eq!(inner.to_string(), ".99");
+    }
+
+    #[test]
+    fn zero() {
+        let time = TimeSpan::zero();
+        let inner = Time::new().format(Some(time));
+        assert_eq!(inner.to_string(), "0");
+        let inner = Fraction::new().format(Some(time));
+        assert_eq!(inner.to_string(), ".00");
+    }
+
+    #[test]
+    fn empty() {
+        let inner = Time::new().format(None);
+        assert_eq!(inner.to_string(), "—");
+        let inner = Fraction::new().format(None);
+        assert_eq!(inner.to_string(), "");
+    }
+
+    #[test]
+    fn slightly_positive() {
+        let time = TimeSpan::from_str("0.000000001").unwrap();
+        let inner = Time::new().format(Some(time));
+        assert_eq!(inner.to_string(), "0");
+        let inner = Fraction::new().format(Some(time));
+        assert_eq!(inner.to_string(), ".00");
+
+        let time = TimeSpan::from_seconds(0.5);
+        let inner = Time::new().format(Some(time));
+        assert_eq!(inner.to_string(), "0");
+        let inner = Fraction::new().format(Some(time));
+        assert_eq!(inner.to_string(), ".50");
+
+        let time = TimeSpan::from_seconds(1.5);
+        let inner = Time::new().format(Some(time));
+        assert_eq!(inner.to_string(), "1");
+        let inner = Fraction::new().format(Some(time));
+        assert_eq!(inner.to_string(), ".50");
+    }
+
+    #[test]
+    fn slightly_negative() {
+        let time = TimeSpan::from_str("-0.000000001").unwrap();
+        let inner = Time::new().format(Some(time));
+        assert_eq!(inner.to_string(), "−0");
+        let inner = Fraction::new().format(Some(time));
+        assert_eq!(inner.to_string(), ".00");
+
+        let time = TimeSpan::from_seconds(-0.5);
+        let inner = Time::new().format(Some(time));
+        assert_eq!(inner.to_string(), "−0");
+        let inner = Fraction::new().format(Some(time));
+        assert_eq!(inner.to_string(), ".50");
+
+        let time = TimeSpan::from_seconds(-1.5);
+        let inner = Time::new().format(Some(time));
+        assert_eq!(inner.to_string(), "−1");
+        let inner = Fraction::new().format(Some(time));
+        assert_eq!(inner.to_string(), ".50");
+    }
+
+    #[test]
+    fn seconds() {
+        let time = TimeSpan::from_str("23.1234").unwrap();
+        let inner = Time::new().format(Some(time));
+        assert_eq!(inner.to_string(), "23");
+        let inner = Fraction::new().format(Some(time));
+        assert_eq!(inner.to_string(), ".12");
+    }
+
+    #[test]
+    fn minutes() {
+        let time = TimeSpan::from_str("12:34.987654321").unwrap();
+        let inner = Time::new().format(Some(time));
+        assert_eq!(inner.to_string(), "12:34");
+        let inner = Fraction::new().format(Some(time));
+        assert_eq!(inner.to_string(), ".98");
+    }
+
+    #[test]
+    fn hours() {
+        let time = TimeSpan::from_str("12:34:56.123456789").unwrap();
+        let inner = Time::new().format(Some(time));
+        assert_eq!(inner.to_string(), "12:34:56");
+        let inner = Fraction::new().format(Some(time));
+        assert_eq!(inner.to_string(), ".12");
+    }
+
+    #[test]
+    fn negative() {
+        let time = TimeSpan::from_str("-12:34:56.123456789").unwrap();
+        let inner = Time::new().format(Some(time));
+        assert_eq!(inner.to_string(), "−12:34:56");
+        let inner = Fraction::new().format(Some(time));
+        assert_eq!(inner.to_string(), ".12");
+    }
+
+    #[test]
+    fn days() {
+        let time = TimeSpan::from_str("2148:34:56.123456789").unwrap();
+        let inner = Time::new().format(Some(time));
+        assert_eq!(inner.to_string(), "2148:34:56");
+        let inner = Fraction::new().format(Some(time));
+        assert_eq!(inner.to_string(), ".12");
+    }
+
+    #[test]
+    fn negative_days() {
+        let time = TimeSpan::from_str("-2148:34:56.123456789").unwrap();
+        let inner = Time::new().format(Some(time));
+        assert_eq!(inner.to_string(), "−2148:34:56");
+        let inner = Fraction::new().format(Some(time));
+        assert_eq!(inner.to_string(), ".12");
+    }
+
+    #[test]
+    fn fractions_default() {
+        let time = TimeSpan::from_str("0.987654321").unwrap();
+        let inner = Fraction::new().format(Some(time));
+        assert_eq!(inner.to_string(), ".98");
+    }
+
+    #[test]
+    fn fractions_seconds() {
+        let time = TimeSpan::from_str("0.987654321").unwrap();
+        let inner = Fraction::with_accuracy(Accuracy::Seconds).format(Some(time));
+        assert_eq!(inner.to_string(), "");
+    }
+
+    #[test]
+    fn fractions_tenths() {
+        let time = TimeSpan::from_str("0.987654321").unwrap();
+        let inner = Fraction::with_accuracy(Accuracy::Tenths).format(Some(time));
+        assert_eq!(inner.to_string(), ".9");
+    }
+
+    #[test]
+    fn fractions_hundredths() {
+        let time = TimeSpan::from_str("0.987654321").unwrap();
+        let inner = Fraction::with_accuracy(Accuracy::Hundredths).format(Some(time));
+        assert_eq!(inner.to_string(), ".98");
+    }
+
+    #[test]
+    fn fractions_milliseconds() {
+        let time = TimeSpan::from_str("0.987654321").unwrap();
+        let inner = Fraction::with_accuracy(Accuracy::Milliseconds).format(Some(time));
+        assert_eq!(inner.to_string(), ".987");
+    }
 }