From bc2c128e4833e48ce59165e28494f11cd73b7256 Mon Sep 17 00:00:00 2001
From: ColeVick <colevick@amazon.com>
Date: Fri, 23 Aug 2024 10:35:51 -0700
Subject: [PATCH] add automatically generated bolero harnesses

---
 Cargo.toml                |    7 +
 src/duration/mod.rs       |  363 +++++++++++
 src/efmt/formatter.rs     |   52 ++
 src/epoch/gregorian.rs    |   53 ++
 src/epoch/leap_seconds.rs |   25 +
 src/epoch/mod.rs          | 1294 +++++++++++++++++++++++++++++++++++++
 src/epoch/system_time.rs  |   14 +
 src/errors.rs             |    2 +
 src/month.rs              |   24 +
 src/parser.rs             |   50 ++
 src/timescale/mod.rs      |   78 +++
 src/timeseries.rs         |   62 ++
 src/timeunits.rs          |   87 +++
 src/weekday.rs            |   96 +++
 14 files changed, 2207 insertions(+)

diff --git a/Cargo.toml b/Cargo.toml
index 138b578..f4cc6f1 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -47,6 +47,7 @@ ut1 = ["std", "reqwest", "tabled", "openssl"]
 serde_json = "1.0.91"
 criterion = "0.5.1"
 iai = "0.1"
+bolero = "0.11.1"
 
 [target.wasm32-unknown-unknown.dependencies]
 js-sys = { version = "0.3" }
@@ -90,3 +91,9 @@ harness = false
 [[bench]]
 name = "iai_epoch"
 harness = false
+
+[profile.fuzz]
+inherits="dev"
+opt-level=3
+incremental=false
+codegen-units=1
diff --git a/src/duration/mod.rs b/src/duration/mod.rs
index 584ccbf..634a26a 100644
--- a/src/duration/mod.rs
+++ b/src/duration/mod.rs
@@ -67,6 +67,7 @@ pub mod ops;
 #[repr(C)]
 #[cfg_attr(feature = "python", pyclass)]
 #[cfg_attr(feature = "python", pyo3(module = "hifitime"))]
+#[cfg_attr(test, derive(bolero::TypeGenerator))]
 pub struct Duration {
     pub(crate) centuries: i16,
     pub(crate) nanoseconds: u64,
@@ -828,3 +829,365 @@ mod ut_duration {
         assert_eq!(nanoseconds, 0);
     }
 }
+/// The following harnesses were automatically generated by an
+/// experimental tool developed by the Kani team.
+#[cfg(test)]
+mod bolero_harnesses {
+    use super::*;
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_159_eq() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|(callee, other): (Duration, Duration)| Some(callee.eq(&other)));
+    }
+
+    /*
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_160_hash() {
+        bolero::check!().with_type().cloned().for_each(|(callee, hasher): (Duration , H/#0)| Some(callee.hash(&hasher)));
+    }
+
+
+    */
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_161_default() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|()| Some(Duration::default()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_162_from_parts() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|(centuries, nanoseconds): (i16, u64)| {
+                Some(Duration::from_parts(centuries, nanoseconds))
+            });
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_163_from_total_nanoseconds() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|nanos: i128| Some(Duration::from_total_nanoseconds(nanos)));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_164_from_truncated_nanoseconds() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|nanos: i64| Some(Duration::from_truncated_nanoseconds(nanos)));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_165_from_days() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|value: f64| Some(Duration::from_days(value)));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_166_from_hours() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|value: f64| Some(Duration::from_hours(value)));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_167_from_seconds() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|value: f64| Some(Duration::from_seconds(value)));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_168_from_milliseconds() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|value: f64| Some(Duration::from_milliseconds(value)));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_169_from_microseconds() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|value: f64| Some(Duration::from_microseconds(value)));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_170_from_nanoseconds() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|value: f64| Some(Duration::from_nanoseconds(value)));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_171_compose() {
+        bolero::check!().with_type().cloned().for_each(
+            |(sign, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds): (
+                i8,
+                u64,
+                u64,
+                u64,
+                u64,
+                u64,
+                u64,
+                u64,
+            )| {
+                Some(Duration::compose(
+                    sign,
+                    days,
+                    hours,
+                    minutes,
+                    seconds,
+                    milliseconds,
+                    microseconds,
+                    nanoseconds,
+                ))
+            },
+        );
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_172_compose_f64() {
+        bolero::check!().with_type().cloned().for_each(
+            |(sign, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds): (
+                i8,
+                f64,
+                f64,
+                f64,
+                f64,
+                f64,
+                f64,
+                f64,
+            )| {
+                Some(Duration::compose_f64(
+                    sign,
+                    days,
+                    hours,
+                    minutes,
+                    seconds,
+                    milliseconds,
+                    microseconds,
+                    nanoseconds,
+                ))
+            },
+        );
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_173_from_tz_offset() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|(sign, hours, minutes): (i8, i64, i64)| {
+                Some(Duration::from_tz_offset(sign, hours, minutes))
+            });
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_174_normalize() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|mut callee: Duration| Some(callee.normalize()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_175_to_parts() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|callee: Duration| Some(callee.to_parts()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_176_total_nanoseconds() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|callee: Duration| Some(callee.total_nanoseconds()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_177_try_truncated_nanoseconds() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|callee: Duration| Some(callee.try_truncated_nanoseconds()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_178_truncated_nanoseconds() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|callee: Duration| Some(callee.truncated_nanoseconds()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_179_to_seconds() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|callee: Duration| Some(callee.to_seconds()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_180_to_unit() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|(callee, unit): (Duration, Unit)| Some(callee.to_unit(unit)));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_181_abs() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|callee: Duration| Some(callee.abs()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_182_signum() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|callee: Duration| Some(callee.signum()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_183_decompose() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|callee: Duration| Some(callee.decompose()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_184_subdivision() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|(callee, unit): (Duration, Unit)| Some(callee.subdivision(unit)));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_185_floor() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|(callee, duration): (Duration, Duration)| Some(callee.floor(duration)));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_186_ceil() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|(callee, duration): (Duration, Duration)| Some(callee.ceil(duration)));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_187_round() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|(callee, duration): (Duration, Duration)| Some(callee.round(duration)));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_188_approx() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|callee: Duration| Some(callee.approx()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_189_min() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|(callee, other): (Duration, Duration)| Some(callee.min(other)));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_190_max() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|(callee, other): (Duration, Duration)| Some(callee.max(other)));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_191_is_negative() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|callee: Duration| Some(callee.is_negative()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_192_eq() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|(callee, unit): (Duration, Unit)| Some(callee.eq(&unit)));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_193_partial_cmp() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|(callee, unit): (Duration, Unit)| Some(callee.partial_cmp(&unit)));
+    }
+}
diff --git a/src/efmt/formatter.rs b/src/efmt/formatter.rs
index 26df41a..e3efb90 100644
--- a/src/efmt/formatter.rs
+++ b/src/efmt/formatter.rs
@@ -19,6 +19,7 @@ use super::format::Format;
 use num_traits::Float;
 
 #[derive(Copy, Clone, Default, Debug, PartialEq)]
+#[cfg_attr(test, derive(bolero::TypeGenerator))]
 pub(crate) struct Item {
     pub(crate) token: Token,
     pub(crate) sep_char: Option<char>,
@@ -302,3 +303,54 @@ impl fmt::Display for Formatter {
         Ok(())
     }
 }
+/// The following harnesses were automatically generated by an
+/// experimental tool developed by the Kani team.
+#[cfg(test)]
+mod bolero_harnesses {
+    use super::*;
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_9_new() {
+        bolero::check!().with_type().cloned().for_each(
+            |(token, sep_char, second_sep_char): (Token, Option<char>, Option<char>)| {
+                Some(Item::new(token, sep_char, second_sep_char))
+            },
+        );
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_10_sep_char_is() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|(callee, c_in): (Item, char)| Some(callee.sep_char_is(c_in)));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_11_sep_char_is_not() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|(callee, c_in): (Item, char)| Some(callee.sep_char_is_not(c_in)));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_12_second_sep_char_is() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|(callee, c_in): (Item, char)| Some(callee.second_sep_char_is(c_in)));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_13_second_sep_char_is_not() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|(callee, c_in): (Item, char)| Some(callee.second_sep_char_is_not(c_in)));
+    }
+}
diff --git a/src/epoch/gregorian.rs b/src/epoch/gregorian.rs
index 8fffb9d..4ed635d 100644
--- a/src/epoch/gregorian.rs
+++ b/src/epoch/gregorian.rs
@@ -795,3 +795,56 @@ mod ut_gregorian {
         }
     }
 }
+/// The following harnesses were automatically generated by an
+/// experimental tool developed by the Kani team.
+#[cfg(test)]
+mod bolero_harnesses {
+    use super::*;
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_0_is_gregorian_valid() {
+        bolero::check!().with_type().cloned().for_each(
+            |(year, month, day, hour, minute, second, nanos): (i32, u8, u8, u8, u8, u8, u32)| {
+                Some(is_gregorian_valid(
+                    year, month, day, hour, minute, second, nanos,
+                ))
+            },
+        );
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_1_january_years() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|year: i32| Some(january_years(year)));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_2_july_years() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|year: i32| Some(july_years(year)));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_3_usual_days_per_month() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|month: u8| Some(usual_days_per_month(month)));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_4_is_leap_year() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|year: i32| Some(is_leap_year(year)));
+    }
+}
diff --git a/src/epoch/leap_seconds.rs b/src/epoch/leap_seconds.rs
index 94ba9bf..7038a40 100644
--- a/src/epoch/leap_seconds.rs
+++ b/src/epoch/leap_seconds.rs
@@ -22,6 +22,7 @@ pub trait LeapSecondProvider: DoubleEndedIterator<Item = LeapSecond> + Index<usi
 #[repr(C)]
 #[cfg_attr(feature = "python", pyclass)]
 #[derive(Copy, Clone, Debug, PartialEq)]
+#[cfg_attr(test, derive(bolero::TypeGenerator))]
 pub struct LeapSecond {
     /// Timestamp in TAI seconds for this leap second, e.g. `2_272_060_800.0` for the first IERS leap second.
     pub timestamp_tai_s: f64,
@@ -161,3 +162,27 @@ fn leap_second_fetch() {
         LeapSecond::new(3_692_217_600.0, 37.0, true)
     );
 }
+/// The following harnesses were automatically generated by an
+/// experimental tool developed by the Kani team.
+#[cfg(test)]
+mod bolero_harnesses {
+    use super::*;
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_19_new() {
+        bolero::check!().with_type().cloned().for_each(
+            |(timestamp_tai_s, delta_at, announced): (f64, f64, bool)| {
+                Some(LeapSecond::new(timestamp_tai_s, delta_at, announced))
+            },
+        );
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_20_default() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|()| Some(LatestLeapSeconds::default()));
+    }
+}
diff --git a/src/epoch/mod.rs b/src/epoch/mod.rs
index 2b2fc1b..4c911b8 100644
--- a/src/epoch/mod.rs
+++ b/src/epoch/mod.rs
@@ -79,6 +79,7 @@ pub const NAIF_K: f64 = 1.657e-3;
 #[repr(C)]
 #[cfg_attr(feature = "python", pyclass)]
 #[cfg_attr(feature = "python", pyo3(module = "hifitime"))]
+#[cfg_attr(test, derive(bolero::TypeGenerator))]
 pub struct Epoch {
     /// An Epoch is always stored as the duration since the beginning of its time scale
     pub duration: Duration,
@@ -1425,3 +1426,1296 @@ mod ut_epoch {
         assert_eq!(e, parsed);
     }
 }
+/// The following harnesses were automatically generated by an
+/// experimental tool developed by the Kani team.
+#[cfg(test)]
+mod bolero_harnesses {
+    use super::*;
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_6_div_rem_f64() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|(me, rhs): (f64, f64)| Some(div_rem_f64(me, rhs)));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_7_div_euclid_f64() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|(lhs, rhs): (f64, f64)| Some(div_euclid_f64(lhs, rhs)));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_8_rem_euclid_f64() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|(lhs, rhs): (f64, f64)| Some(rem_euclid_f64(lhs, rhs)));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_21_to_time_scale() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|(callee, ts): (Epoch, TimeScale)| Some(callee.to_time_scale(ts)));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_22_from_tai_duration() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|duration: Duration| Some(Epoch::from_tai_duration(duration)));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_23_from_duration() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|(duration, ts): (Duration, TimeScale)| {
+                Some(Epoch::from_duration(duration, ts))
+            });
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_24_to_duration_since_j1900() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|callee: Epoch| Some(callee.to_duration_since_j1900()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_25_from_tai_parts() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|(centuries, nanoseconds): (i16, u64)| {
+                Some(Epoch::from_tai_parts(centuries, nanoseconds))
+            });
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_26_from_tai_seconds() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|seconds: f64| Some(Epoch::from_tai_seconds(seconds)));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_27_from_tai_days() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|days: f64| Some(Epoch::from_tai_days(days)));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_28_from_utc_duration() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|duration: Duration| Some(Epoch::from_utc_duration(duration)));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_29_from_utc_seconds() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|seconds: f64| Some(Epoch::from_utc_seconds(seconds)));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_30_from_utc_days() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|days: f64| Some(Epoch::from_utc_days(days)));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_31_from_gpst_duration() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|duration: Duration| Some(Epoch::from_gpst_duration(duration)));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_32_from_qzsst_duration() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|duration: Duration| Some(Epoch::from_qzsst_duration(duration)));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_33_from_gst_duration() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|duration: Duration| Some(Epoch::from_gst_duration(duration)));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_34_from_bdt_duration() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|duration: Duration| Some(Epoch::from_bdt_duration(duration)));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_35_from_mjd_tai() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|days: f64| Some(Epoch::from_mjd_tai(days)));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_36_from_mjd_in_time_scale() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|(days, time_scale): (f64, TimeScale)| {
+                Some(Epoch::from_mjd_in_time_scale(days, time_scale))
+            });
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_37_from_mjd_utc() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|days: f64| Some(Epoch::from_mjd_utc(days)));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_38_from_mjd_gpst() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|days: f64| Some(Epoch::from_mjd_gpst(days)));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_39_from_mjd_qzsst() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|days: f64| Some(Epoch::from_mjd_qzsst(days)));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_40_from_mjd_gst() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|days: f64| Some(Epoch::from_mjd_gst(days)));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_41_from_mjd_bdt() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|days: f64| Some(Epoch::from_mjd_bdt(days)));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_42_from_jde_tai() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|days: f64| Some(Epoch::from_jde_tai(days)));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_43_from_jde_in_time_scale() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|(days, time_scale): (f64, TimeScale)| {
+                Some(Epoch::from_jde_in_time_scale(days, time_scale))
+            });
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_44_from_jde_utc() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|days: f64| Some(Epoch::from_jde_utc(days)));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_45_from_jde_gpst() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|days: f64| Some(Epoch::from_jde_gpst(days)));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_46_from_jde_qzsst() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|days: f64| Some(Epoch::from_jde_qzsst(days)));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_47_from_jde_gst() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|days: f64| Some(Epoch::from_jde_gst(days)));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_48_from_jde_bdt() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|days: f64| Some(Epoch::from_jde_bdt(days)));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_49_from_tt_seconds() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|seconds: f64| Some(Epoch::from_tt_seconds(seconds)));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_50_from_tt_duration() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|duration: Duration| Some(Epoch::from_tt_duration(duration)));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_51_from_et_seconds() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|seconds_since_j2000: f64| Some(Epoch::from_et_seconds(seconds_since_j2000)));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_52_from_et_duration() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|duration_since_j2000: Duration| {
+                Some(Epoch::from_et_duration(duration_since_j2000))
+            });
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_53_from_tdb_seconds() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|seconds_j2000: f64| Some(Epoch::from_tdb_seconds(seconds_j2000)));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_54_from_tdb_duration() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|duration_since_j2000: Duration| {
+                Some(Epoch::from_tdb_duration(duration_since_j2000))
+            });
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_55_from_jde_et() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|days: f64| Some(Epoch::from_jde_et(days)));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_56_from_jde_tdb() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|days: f64| Some(Epoch::from_jde_tdb(days)));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_57_from_gpst_seconds() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|seconds: f64| Some(Epoch::from_gpst_seconds(seconds)));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_58_from_gpst_days() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|days: f64| Some(Epoch::from_gpst_days(days)));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_59_from_gpst_nanoseconds() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|nanoseconds: u64| Some(Epoch::from_gpst_nanoseconds(nanoseconds)));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_60_from_qzsst_seconds() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|seconds: f64| Some(Epoch::from_qzsst_seconds(seconds)));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_61_from_qzsst_days() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|days: f64| Some(Epoch::from_qzsst_days(days)));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_62_from_qzsst_nanoseconds() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|nanoseconds: u64| Some(Epoch::from_qzsst_nanoseconds(nanoseconds)));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_63_from_gst_seconds() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|seconds: f64| Some(Epoch::from_gst_seconds(seconds)));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_64_from_gst_days() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|days: f64| Some(Epoch::from_gst_days(days)));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_65_from_gst_nanoseconds() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|nanoseconds: u64| Some(Epoch::from_gst_nanoseconds(nanoseconds)));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_66_from_bdt_seconds() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|seconds: f64| Some(Epoch::from_bdt_seconds(seconds)));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_67_from_bdt_days() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|days: f64| Some(Epoch::from_bdt_days(days)));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_68_from_bdt_nanoseconds() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|nanoseconds: u64| Some(Epoch::from_bdt_nanoseconds(nanoseconds)));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_69_from_unix_duration() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|duration: Duration| Some(Epoch::from_unix_duration(duration)));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_70_from_unix_seconds() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|seconds: f64| Some(Epoch::from_unix_seconds(seconds)));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_71_from_unix_milliseconds() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|millisecond: f64| Some(Epoch::from_unix_milliseconds(millisecond)));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_72_delta_et_tai() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|seconds: f64| Some(Epoch::delta_et_tai(seconds)));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_73_inner_g() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|seconds: f64| Some(Epoch::inner_g(seconds)));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_74_from_time_of_week() {
+        bolero::check!().with_type().cloned().for_each(
+            |(week, nanoseconds, time_scale): (u32, u64, TimeScale)| {
+                Some(Epoch::from_time_of_week(week, nanoseconds, time_scale))
+            },
+        );
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_75_from_time_of_week_utc() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|(week, nanoseconds): (u32, u64)| {
+                Some(Epoch::from_time_of_week_utc(week, nanoseconds))
+            });
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_76_from_day_of_year() {
+        bolero::check!().with_type().cloned().for_each(
+            |(year, days, time_scale): (i32, f64, TimeScale)| {
+                Some(Epoch::from_day_of_year(year, days, time_scale))
+            },
+        );
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_77_leap_seconds_iers() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|callee: Epoch| Some(callee.leap_seconds_iers()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_78_leap_seconds() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|(callee, iers_only): (Epoch, bool)| Some(callee.leap_seconds(iers_only)));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_79_to_isoformat() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|callee: Epoch| Some(callee.to_isoformat()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_80_to_duration_in_time_scale() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|(callee, ts): (Epoch, TimeScale)| {
+                Some(callee.to_duration_in_time_scale(ts))
+            });
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_81_to_nanoseconds_in_time_scale() {
+        bolero::check!().with_type().cloned().for_each(
+            |(callee, time_scale): (Epoch, TimeScale)| {
+                Some(callee.to_nanoseconds_in_time_scale(time_scale))
+            },
+        );
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_82_to_tai_seconds() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|callee: Epoch| Some(callee.to_tai_seconds()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_83_to_tai_duration() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|callee: Epoch| Some(callee.to_tai_duration()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_84_to_tai() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|(callee, unit): (Epoch, Unit)| Some(callee.to_tai(unit)));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_85_to_tai_parts() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|callee: Epoch| Some(callee.to_tai_parts()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_86_to_tai_days() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|callee: Epoch| Some(callee.to_tai_days()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_87_to_utc_seconds() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|callee: Epoch| Some(callee.to_utc_seconds()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_88_to_utc_duration() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|callee: Epoch| Some(callee.to_utc_duration()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_89_to_utc() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|(callee, unit): (Epoch, Unit)| Some(callee.to_utc(unit)));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_90_to_utc_days() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|callee: Epoch| Some(callee.to_utc_days()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_91_to_mjd_tai_days() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|callee: Epoch| Some(callee.to_mjd_tai_days()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_92_to_mjd_tai_seconds() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|callee: Epoch| Some(callee.to_mjd_tai_seconds()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_93_to_mjd_tai() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|(callee, unit): (Epoch, Unit)| Some(callee.to_mjd_tai(unit)));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_94_to_mjd_utc_days() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|callee: Epoch| Some(callee.to_mjd_utc_days()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_95_to_mjd_utc() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|(callee, unit): (Epoch, Unit)| Some(callee.to_mjd_utc(unit)));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_96_to_mjd_utc_seconds() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|callee: Epoch| Some(callee.to_mjd_utc_seconds()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_97_to_jde_tai_days() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|callee: Epoch| Some(callee.to_jde_tai_days()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_98_to_jde_tai() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|(callee, unit): (Epoch, Unit)| Some(callee.to_jde_tai(unit)));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_99_to_jde_tai_duration() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|callee: Epoch| Some(callee.to_jde_tai_duration()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_100_to_jde_tai_seconds() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|callee: Epoch| Some(callee.to_jde_tai_seconds()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_101_to_jde_utc_days() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|callee: Epoch| Some(callee.to_jde_utc_days()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_102_to_jde_utc_duration() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|callee: Epoch| Some(callee.to_jde_utc_duration()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_103_to_jde_utc_seconds() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|callee: Epoch| Some(callee.to_jde_utc_seconds()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_104_to_tt_seconds() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|callee: Epoch| Some(callee.to_tt_seconds()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_105_to_tt_duration() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|callee: Epoch| Some(callee.to_tt_duration()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_106_to_tt_days() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|callee: Epoch| Some(callee.to_tt_days()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_107_to_tt_centuries_j2k() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|callee: Epoch| Some(callee.to_tt_centuries_j2k()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_108_to_tt_since_j2k() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|callee: Epoch| Some(callee.to_tt_since_j2k()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_109_to_jde_tt_days() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|callee: Epoch| Some(callee.to_jde_tt_days()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_110_to_jde_tt_duration() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|callee: Epoch| Some(callee.to_jde_tt_duration()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_111_to_mjd_tt_days() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|callee: Epoch| Some(callee.to_mjd_tt_days()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_112_to_mjd_tt_duration() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|callee: Epoch| Some(callee.to_mjd_tt_duration()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_113_to_gpst_seconds() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|callee: Epoch| Some(callee.to_gpst_seconds()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_114_to_gpst_duration() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|callee: Epoch| Some(callee.to_gpst_duration()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_115_to_gpst_nanoseconds() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|callee: Epoch| Some(callee.to_gpst_nanoseconds()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_116_to_gpst_days() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|callee: Epoch| Some(callee.to_gpst_days()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_117_to_qzsst_seconds() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|callee: Epoch| Some(callee.to_qzsst_seconds()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_118_to_qzsst_duration() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|callee: Epoch| Some(callee.to_qzsst_duration()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_119_to_qzsst_nanoseconds() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|callee: Epoch| Some(callee.to_qzsst_nanoseconds()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_120_to_qzsst_days() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|callee: Epoch| Some(callee.to_qzsst_days()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_121_to_gst_seconds() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|callee: Epoch| Some(callee.to_gst_seconds()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_122_to_gst_duration() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|callee: Epoch| Some(callee.to_gst_duration()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_123_to_gst_nanoseconds() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|callee: Epoch| Some(callee.to_gst_nanoseconds()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_124_to_gst_days() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|callee: Epoch| Some(callee.to_gst_days()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_125_to_bdt_seconds() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|callee: Epoch| Some(callee.to_bdt_seconds()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_126_to_bdt_duration() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|callee: Epoch| Some(callee.to_bdt_duration()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_127_to_bdt_days() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|callee: Epoch| Some(callee.to_bdt_days()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_128_to_bdt_nanoseconds() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|callee: Epoch| Some(callee.to_bdt_nanoseconds()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_129_to_unix_duration() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|callee: Epoch| Some(callee.to_unix_duration()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_130_to_unix() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|(callee, unit): (Epoch, Unit)| Some(callee.to_unix(unit)));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_131_to_unix_seconds() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|callee: Epoch| Some(callee.to_unix_seconds()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_132_to_unix_milliseconds() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|callee: Epoch| Some(callee.to_unix_milliseconds()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_133_to_unix_days() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|callee: Epoch| Some(callee.to_unix_days()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_134_to_et_seconds() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|callee: Epoch| Some(callee.to_et_seconds()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_135_to_et_duration() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|callee: Epoch| Some(callee.to_et_duration()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_136_to_tdb_duration() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|callee: Epoch| Some(callee.to_tdb_duration()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_137_to_tdb_seconds() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|callee: Epoch| Some(callee.to_tdb_seconds()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_138_to_jde_et_days() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|callee: Epoch| Some(callee.to_jde_et_days()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_139_to_jde_et_duration() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|callee: Epoch| Some(callee.to_jde_et_duration()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_140_to_jde_et() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|(callee, unit): (Epoch, Unit)| Some(callee.to_jde_et(unit)));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_141_to_jde_tdb_duration() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|callee: Epoch| Some(callee.to_jde_tdb_duration()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_142_to_jde_tdb_days() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|callee: Epoch| Some(callee.to_jde_tdb_days()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_143_to_tdb_days_since_j2000() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|callee: Epoch| Some(callee.to_tdb_days_since_j2000()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_144_to_tdb_centuries_since_j2000() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|callee: Epoch| Some(callee.to_tdb_centuries_since_j2000()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_145_to_et_days_since_j2000() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|callee: Epoch| Some(callee.to_et_days_since_j2000()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_146_to_et_centuries_since_j2000() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|callee: Epoch| Some(callee.to_et_centuries_since_j2000()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_147_duration_in_year() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|callee: Epoch| Some(callee.duration_in_year()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_148_day_of_year() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|callee: Epoch| Some(callee.day_of_year()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_149_year() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|callee: Epoch| Some(callee.year()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_150_year_days_of_year() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|callee: Epoch| Some(callee.year_days_of_year()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_151_hours() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|callee: Epoch| Some(callee.hours()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_152_minutes() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|callee: Epoch| Some(callee.minutes()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_153_seconds() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|callee: Epoch| Some(callee.seconds()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_154_milliseconds() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|callee: Epoch| Some(callee.milliseconds()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_155_microseconds() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|callee: Epoch| Some(callee.microseconds()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_156_nanoseconds() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|callee: Epoch| Some(callee.nanoseconds()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_157_month_name() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|callee: Epoch| Some(callee.month_name()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_158_to_rfc3339() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|callee: Epoch| Some(callee.to_rfc3339()));
+    }
+}
diff --git a/src/epoch/system_time.rs b/src/epoch/system_time.rs
index a2afdaa..15ab9d2 100644
--- a/src/epoch/system_time.rs
+++ b/src/epoch/system_time.rs
@@ -34,3 +34,17 @@ impl Epoch {
         Ok(Self::from_unix_duration(duration))
     }
 }
+/// The following harnesses were automatically generated by an
+/// experimental tool developed by the Kani team.
+#[cfg(test)]
+mod bolero_harnesses {
+    use super::*;
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_5_duration_since_unix_epoch() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|()| Some(duration_since_unix_epoch()));
+    }
+}
diff --git a/src/errors.rs b/src/errors.rs
index 222e0c5..028e4c8 100644
--- a/src/errors.rs
+++ b/src/errors.rs
@@ -42,6 +42,8 @@ pub enum EpochError {
 
 #[non_exhaustive]
 #[derive(Debug, Snafu, PartialEq)]
+#[cfg_attr(test, derive(Clone))]
+#[cfg_attr(test, derive(bolero::TypeGenerator))]
 pub enum DurationError {
     Overflow,
     Underflow,
diff --git a/src/month.rs b/src/month.rs
index 417cf6c..6d8332e 100644
--- a/src/month.rs
+++ b/src/month.rs
@@ -22,6 +22,7 @@ use serde_derive::{Deserialize, Serialize};
 #[repr(u8)]
 #[cfg_attr(feature = "python", pyclass)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(test, derive(bolero::TypeGenerator))]
 pub enum MonthName {
     January,
     February,
@@ -109,3 +110,26 @@ impl fmt::LowerHex for MonthName {
         }
     }
 }
+/// The following harnesses were automatically generated by an
+/// experimental tool developed by the Kani team.
+#[cfg(test)]
+mod bolero_harnesses {
+    use super::*;
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_227_default() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|()| Some(MonthName::default()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_228_from() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|u: u8| Some(MonthName::from(u)));
+    }
+}
diff --git a/src/parser.rs b/src/parser.rs
index 75c346d..00f18f7 100644
--- a/src/parser.rs
+++ b/src/parser.rs
@@ -11,6 +11,7 @@
 use crate::{EpochError, ParsingError};
 
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
+#[cfg_attr(test, derive(bolero::TypeGenerator))]
 pub(crate) enum Token {
     Year,
     YearShort,
@@ -277,3 +278,52 @@ impl Token {
         )
     }
 }
+/// The following harnesses were automatically generated by an
+/// experimental tool developed by the Kani team.
+#[cfg(test)]
+mod bolero_harnesses {
+    use super::*;
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_14_default() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|()| Some(Token::default()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_15_value_ok() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|(callee, val): (Token, i32)| Some(callee.value_ok(val)));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_16_gregorian_position() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|callee: Token| Some(callee.gregorian_position()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_17_advance_with() {
+        bolero::check!().with_type().cloned().for_each(
+            |(mut callee, ending_char): (Token, char)| Some(callee.advance_with(ending_char)),
+        );
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_18_is_numeric() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|callee: Token| Some(callee.is_numeric()));
+    }
+}
diff --git a/src/timescale/mod.rs b/src/timescale/mod.rs
index 17cdf6f..74d217c 100644
--- a/src/timescale/mod.rs
+++ b/src/timescale/mod.rs
@@ -84,6 +84,7 @@ pub(crate) const HIFITIME_REF_YEAR: i32 = 1900;
 #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
 #[cfg_attr(feature = "python", pyclass)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(test, derive(bolero::TypeGenerator))]
 pub enum TimeScale {
     /// TAI is the representation of an Epoch internally
     TAI,
@@ -262,3 +263,80 @@ mod unit_test_timescale {
         );
     }
 }
+/// The following harnesses were automatically generated by an
+/// experimental tool developed by the Kani team.
+#[cfg(test)]
+mod bolero_harnesses {
+    use super::*;
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_194_default() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|()| Some(TimeScale::default()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_195_formatted_len() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|callee: TimeScale| Some(callee.formatted_len()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_196_is_gnss() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|callee: TimeScale| Some(callee.is_gnss()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_197_reference_epoch() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|callee: TimeScale| Some(callee.reference_epoch()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_198_prime_epoch_offset() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|callee: TimeScale| Some(callee.prime_epoch_offset()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_199_gregorian_epoch_offset() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|callee: TimeScale| Some(callee.gregorian_epoch_offset()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_200_uses_leap_seconds() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|callee: TimeScale| Some(callee.uses_leap_seconds()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_201_from() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|val: u8| Some(TimeScale::from(val)));
+    }
+}
diff --git a/src/timeseries.rs b/src/timeseries.rs
index f9cea4a..ee4d29a 100644
--- a/src/timeseries.rs
+++ b/src/timeseries.rs
@@ -29,6 +29,7 @@ NOTE: This is taken from itertools: https://docs.rs/itertools-num/0.1.3/src/iter
 #[derive(Clone, Debug, PartialEq, Eq)]
 #[cfg_attr(feature = "python", pyclass)]
 #[cfg_attr(feature = "python", pyo3(module = "hifitime"))]
+#[cfg_attr(test, derive(bolero::TypeGenerator))]
 pub struct TimeSeries {
     start: Epoch,
     duration: Duration,
@@ -415,3 +416,64 @@ mod tests {
         assert_eq!(cur_epoch, start, "incorrect last item in iterator");
     }
 }
+/// The following harnesses were automatically generated by an
+/// experimental tool developed by the Kani team.
+#[cfg(test)]
+mod bolero_harnesses {
+    use super::*;
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_211_exclusive() {
+        bolero::check!().with_type().cloned().for_each(
+            |(start, end, step): (Epoch, Epoch, Duration)| {
+                Some(TimeSeries::exclusive(start, end, step))
+            },
+        );
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_212_inclusive() {
+        bolero::check!().with_type().cloned().for_each(
+            |(start, end, step): (Epoch, Epoch, Duration)| {
+                Some(TimeSeries::inclusive(start, end, step))
+            },
+        );
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_213_next() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|mut callee: TimeSeries| Some(callee.next()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_214_size_hint() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|callee: TimeSeries| Some(callee.size_hint()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_215_next_back() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|mut callee: TimeSeries| Some(callee.next_back()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_216_len() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|callee: TimeSeries| Some(callee.len()));
+    }
+}
diff --git a/src/timeunits.rs b/src/timeunits.rs
index b334b45..9198b56 100644
--- a/src/timeunits.rs
+++ b/src/timeunits.rs
@@ -27,6 +27,7 @@ use crate::{
 /// An Enum to perform time unit conversions.
 #[derive(Copy, Clone, Debug, PartialEq, PartialOrd, Eq, Ord)]
 #[cfg_attr(feature = "python", pyclass)]
+#[cfg_attr(test, derive(bolero::TypeGenerator))]
 pub enum Unit {
     Nanosecond,
     Microsecond,
@@ -332,3 +333,89 @@ fn test_unit_conversion() {
         }
     }
 }
+/// The following harnesses were automatically generated by an
+/// experimental tool developed by the Kani team.
+#[cfg(test)]
+mod bolero_harnesses {
+    use super::*;
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_202_default() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|()| Some(Unit::default()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_203_default() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|()| Some(Freq::default()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_204_add() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|(callee, rhs): (Unit, Unit)| Some(callee.add(rhs)));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_205_sub() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|(callee, rhs): (Unit, Unit)| Some(callee.sub(rhs)));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_206_in_seconds() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|callee: Unit| Some(callee.in_seconds()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_207_from_seconds() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|callee: Unit| Some(callee.from_seconds()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_208_from() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|val: u8| Some(Unit::from(val)));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_209_mul() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|(callee, q): (Unit, i64)| Some(callee.mul(q)));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_210_mul() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|(callee, q): (Unit, f64)| Some(callee.mul(q)));
+    }
+}
diff --git a/src/weekday.rs b/src/weekday.rs
index 3852f55..d0340f2 100644
--- a/src/weekday.rs
+++ b/src/weekday.rs
@@ -23,6 +23,7 @@ use serde_derive::{Deserialize, Serialize};
 #[repr(u8)]
 #[cfg_attr(feature = "python", pyclass)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(test, derive(bolero::TypeGenerator))]
 pub enum Weekday {
     Monday = 0,
     Tuesday = 1,
@@ -202,3 +203,98 @@ fn test_iso_weekday() {
     assert_eq!(Weekday::Friday.to_c89_weekday(), 5);
     assert_eq!(Weekday::Saturday.to_c89_weekday(), 6);
 }
+/// The following harnesses were automatically generated by an
+/// experimental tool developed by the Kani team.
+#[cfg(test)]
+mod bolero_harnesses {
+    use super::*;
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_217_default() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|()| Some(Weekday::default()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_218_to_c89_weekday() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|callee: Weekday| Some(callee.to_c89_weekday()));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_219_from() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|u: u8| Some(Weekday::from(u)));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_220_from() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|i: i8| Some(Weekday::from(i)));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_221_add() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|(callee, rhs): (Weekday, Weekday)| Some(callee.add(rhs)));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_222_sub() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|(callee, rhs): (Weekday, Weekday)| Some(callee.sub(rhs)));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_223_add() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|(callee, rhs): (Weekday, u8)| Some(callee.add(rhs)));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_224_sub() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|(callee, rhs): (Weekday, u8)| Some(callee.sub(rhs)));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_225_add_assign() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|(mut callee, rhs): (Weekday, u8)| Some(callee.add_assign(rhs)));
+    }
+
+    #[test]
+    #[cfg_attr(kani, kani::proof)]
+    fn bolero_test_226_sub_assign() {
+        bolero::check!()
+            .with_type()
+            .cloned()
+            .for_each(|(mut callee, rhs): (Weekday, u8)| Some(callee.sub_assign(rhs)));
+    }
+}