it is now possible to run cargo miri

src/time/ascii.rs

@@ -71,7 +71,19 @@ mod tests {
     use std::format;
 
     #[test]
-    fn test_ascii_timestamp_a_unterminated() {
+    fn test_ascii_timestamp_a_unterminated_epoch() {
+        let date = chrono::DateTime::UNIX_EPOCH;
+        let stamp_formatter = generate_time_code_a(&date);
+        let stamp = format!("{}", stamp_formatter);
+        let t_sep = stamp.find('T');
+        assert!(t_sep.is_some());
+        assert_eq!(t_sep.unwrap(), 10);
+        assert_eq!(stamp.len(), FMT_STR_CODE_A_WITH_SIZE.1);
+    }
+
+    #[test]
+    #[cfg_attr(miri, ignore)]
+    fn test_ascii_timestamp_a_unterminated_now() {
         let date = Utc::now();
         let stamp_formatter = generate_time_code_a(&date);
         let stamp = format!("{}", stamp_formatter);
@@ -82,7 +94,24 @@ mod tests {
     }
 
     #[test]
-    fn test_ascii_timestamp_a_terminated() {
+    fn test_ascii_timestamp_a_terminated_epoch() {
+        let date = chrono::DateTime::UNIX_EPOCH;
+        let stamp_formatter = generate_time_code_a_terminated(&date);
+        let stamp = format!("{}", stamp_formatter);
+        let t_sep = stamp.find('T');
+        assert!(t_sep.is_some());
+        assert_eq!(t_sep.unwrap(), 10);
+        let z_terminator = stamp.find('Z');
+        assert!(z_terminator.is_some());
+        assert_eq!(
+            z_terminator.unwrap(),
+            FMT_STR_CODE_A_TERMINATED_WITH_SIZE.1 - 1
+        );
+        assert_eq!(stamp.len(), FMT_STR_CODE_A_TERMINATED_WITH_SIZE.1);
+    }
+    #[test]
+    #[cfg_attr(miri, ignore)]
+    fn test_ascii_timestamp_a_terminated_now() {
         let date = Utc::now();
         let stamp_formatter = generate_time_code_a_terminated(&date);
         let stamp = format!("{}", stamp_formatter);
@@ -99,7 +128,19 @@ mod tests {
     }
 
     #[test]
-    fn test_ascii_timestamp_b_unterminated() {
+    fn test_ascii_timestamp_b_unterminated_epoch() {
+        let date = chrono::DateTime::UNIX_EPOCH;
+        let stamp_formatter = generate_time_code_b(&date);
+        let stamp = format!("{}", stamp_formatter);
+        let t_sep = stamp.find('T');
+        assert!(t_sep.is_some());
+        assert_eq!(t_sep.unwrap(), 8);
+        assert_eq!(stamp.len(), FMT_STR_CODE_B_WITH_SIZE.1);
+    }
+
+    #[test]
+    #[cfg_attr(miri, ignore)]
+    fn test_ascii_timestamp_b_unterminated_now() {
         let date = Utc::now();
         let stamp_formatter = generate_time_code_b(&date);
         let stamp = format!("{}", stamp_formatter);
@@ -110,7 +151,25 @@ mod tests {
     }
 
     #[test]
-    fn test_ascii_timestamp_b_terminated() {
+    fn test_ascii_timestamp_b_terminated_epoch() {
+        let date = chrono::DateTime::UNIX_EPOCH;
+        let stamp_formatter = generate_time_code_b_terminated(&date);
+        let stamp = format!("{}", stamp_formatter);
+        let t_sep = stamp.find('T');
+        assert!(t_sep.is_some());
+        assert_eq!(t_sep.unwrap(), 8);
+        let z_terminator = stamp.find('Z');
+        assert!(z_terminator.is_some());
+        assert_eq!(
+            z_terminator.unwrap(),
+            FMT_STR_CODE_B_TERMINATED_WITH_SIZE.1 - 1
+        );
+        assert_eq!(stamp.len(), FMT_STR_CODE_B_TERMINATED_WITH_SIZE.1);
+    }
+
+    #[test]
+    #[cfg_attr(miri, ignore)]
+    fn test_ascii_timestamp_b_terminated_now() {
         let date = Utc::now();
         let stamp_formatter = generate_time_code_b_terminated(&date);
         let stamp = format!("{}", stamp_formatter);

src/time/cds.rs

@@ -1622,6 +1622,7 @@ mod tests {
     }
 
     #[test]
+    #[cfg_attr(miri, ignore)]
     fn test_time_now() {
         let timestamp_now = CdsTime::now_with_u16_days().unwrap();
         let compare_stamp = chrono::Utc::now();
@@ -1629,6 +1630,7 @@ mod tests {
     }
 
     #[test]
+    #[cfg_attr(miri, ignore)]
     fn test_time_now_us_prec() {
         let timestamp_now = CdsTime::now_with_u16_days_us_precision().unwrap();
         let compare_stamp = chrono::Utc::now();
@@ -1636,6 +1638,7 @@ mod tests {
     }
 
     #[test]
+    #[cfg_attr(miri, ignore)]
     fn test_time_now_ps_prec() {
         let timestamp_now = CdsTime::from_now_with_u16_days_ps_precision().unwrap();
         let compare_stamp = chrono::Utc::now();
@@ -1643,6 +1646,7 @@ mod tests {
     }
 
     #[test]
+    #[cfg_attr(miri, ignore)]
     fn test_time_now_ps_prec_u16_days() {
         let timestamp_now = CdsTime::from_now_with_u16_days_ps_precision().unwrap();
         let compare_stamp = chrono::Utc::now();
@@ -1650,6 +1654,7 @@ mod tests {
     }
 
     #[test]
+    #[cfg_attr(miri, ignore)]
     fn test_time_now_ps_prec_u24_days() {
         let timestamp_now = CdsTime::now_with_u24_days_ps_precision().unwrap();
         let compare_stamp = chrono::Utc::now();
@@ -2306,6 +2311,7 @@ mod tests {
     }
 
     #[test]
+    #[cfg_attr(miri, ignore)]
     fn test_update_from_now() {
         let mut stamp = CdsTime::new_with_u16_days(0, 0);
         let _ = stamp.update_from_now();
@@ -2321,6 +2327,7 @@ mod tests {
 
     #[test]
     #[cfg(feature = "serde")]
+    #[cfg_attr(miri, ignore)]
     fn test_serialization() {
         let stamp_now = CdsTime::now_with_u16_days().expect("Error retrieving time");
         let val = to_allocvec(&stamp_now).expect("Serializing timestamp failed");

src/time/cuc.rs

@@ -947,6 +947,7 @@ mod tests {
     }
 
     #[test]
+    #[cfg_attr(miri, ignore)]
     fn test_datetime_now() {
         let now = chrono::Utc::now();
         let cuc_now = CucTime::now(FractionalResolution::SixtyNs, LEAP_SECONDS);
@@ -1278,6 +1279,7 @@ mod tests {
     }
 
     #[test]
+    #[cfg_attr(miri, ignore)]
     fn set_fract_resolution() {
         let mut stamp = CucTime::new(2000);
         stamp.set_fractional_resolution(FractionalResolution::SixtyNs);

src/time/mod.rs

@@ -551,6 +551,7 @@ mod tests {
     }
 
     #[test]
+    #[cfg_attr(miri, ignore)]
     fn test_get_current_time() {
         let sec_floats = seconds_since_epoch();
         assert!(sec_floats > 0.0);
@@ -565,6 +566,7 @@ mod tests {
     }
 
     #[test]
+    #[cfg_attr(miri, ignore)]
     fn test_ccsds_epoch() {
         let now = SystemTime::now()
             .duration_since(SystemTime::UNIX_EPOCH)
@@ -685,6 +687,7 @@ mod tests {
     }
 
     #[test]
+    #[cfg_attr(miri, ignore)]
     fn test_from_now() {
         let stamp_now = UnixTime::now().unwrap();
         let dt_now = stamp_now.chrono_date_time().unwrap();