diff --git a/CHANGELOG.md b/CHANGELOG.md index f02d741..944ec13 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -8,27 +8,58 @@ and this project adheres to [Semantic Versioning](http://semver.org/). # [unreleased] +The timestamp of `PusTm` is now optional. See Added and Changed section for details. + ## Added -- CDS timestamp: Added constructor function to create the time provider +- `PusTmSecondaryHeader`: New `new_simple_no_timestamp` API to create secondary header without + timestamp. +- `PusTm`: Add `new_simple_no_timestamp` method to create TM without timestamp +- New `UnixTimestamp` abstraction which contains the unix seconds as an `i64` + and an optional subsecond millisecond counter (`u16`) +- `MS_PER_DAY` constant. + +### CDS time module + +- Implement `Add` and `AddAssign` for time providers, which allows + easily adding offsets to the providers. +- Implement `TryFrom>` for time providers. +- `get_dyn_time_provider_from_bytes`: Requires `alloc` support and returns + the correct `TimeProvider` instance wrapped as a boxed trait object + `Box` by checking the length of days field. +- Added constructor function to create the time provider from `chrono::DateTime` and a generic UNIX timestamp (`i64` seconds and subsecond milliseconds). -- New `UnixTimeStamp` abstraction which contains the unix seconds as an `i64` - and an optional subsecond millisecond counter (`u16`) - `MAX_DAYS_24_BITS` which contains maximum value which can be supplied to the days field of a CDS time provider with 24 bits days field width. +- New `CdsTimestamp` trait which encapsulates common fields for all CDS time providers. +- `from_unix_secs_with_u24_days` and `from_unix_secs_with_u16_days` which create + the time provider from a `UnixTimestamp` reference. +- `from_dt_with_u16_days`, `from_dt_with_u24_days` and their `..._us_precision` and + `..._ps_precision` variants which allow to create time providers from + a `chrono::DateTime`. +- Add `from_bytes_with_u24_days` and `from_bytes_with_u16_days` associated methods ## Changed +- (breaking) `PusTmSecondaryHeader`: Timestamp is optional now, which translates to a + timestamp of size 0. +- (breaking): `PusTm`: Renamed `time_stamp` method to `timestamp`, also returns + `Optional<&'src_data [u8]>` now. +- (breaking): `PusTmSecondaryHeader`: Renamed `time_stamp` field to `timestamp` for consistency. +- (breaking): Renamed `from_now_with_u24_days_and_us_prec` to `from_now_with_u24_days_us_precision`. + Also did the same for the `u16` variant. +- (breaking): Renamed `from_now_with_u24_days_and_ps_prec` to `from_now_with_u24_days_ps_precision`. + Also did the same for the `u16` variant. - `CcsdsTimeProvider` trait (breaking): - - Add new `unix_stamp` method returning the new `UnixTimeStamp` struct - - Add new `subsecond_millis` method returning counter `Option` + - Add new `unix_stamp` method returning the new `UnixTimeStamp` struct. + - Add new `subsecond_millis` method returning counter `Option`. - Default impl for `unix_stamp` which re-uses `subsecond_millis` and - existing `unix_seconds` method + existing `unix_seconds` method. - `TimestampError` (breaking): Add `DateBeforeCcsdsEpoch` error type because new CDS API allow supplying invalid date times before CCSDS epoch. Make `TimestampError` with `#[non_exhaustive]` attribute to prevent - future breakages if new error variants are added + future breakages if new error variants are added. # [v0.4.2] 14.01.2023 diff --git a/src/time/cds.rs b/src/time/cds.rs index 6e808ec..092c145 100644 --- a/src/time/cds.rs +++ b/src/time/cds.rs @@ -180,7 +180,7 @@ pub trait CdsCommon { } /// Generic properties for all CDS time providers. -pub trait CdsTimeStamp: CdsCommon { +pub trait CdsTimestamp: CdsCommon { fn len_of_day_seg(&self) -> LengthOfDaySegment; } @@ -388,18 +388,14 @@ impl CdsConverter for ConversionFromNow { } #[cfg(feature = "alloc")] -pub trait DynCdsTimeProvider: CcsdsTimeProvider + CdsTimeStamp + TimeWriter + Any {} +pub trait DynCdsTimeProvider: CcsdsTimeProvider + CdsTimestamp + TimeWriter + Any {} #[cfg(feature = "alloc")] impl DynCdsTimeProvider for TimeProvider {} #[cfg(feature = "alloc")] impl DynCdsTimeProvider for TimeProvider {} /// This function returns the correct [TimeProvider] instance from a raw byte array -/// by checking the days of length field. It also checks the CCSDS time code for correctness. -/// -/// The time provider instance is returned as a [DynCdsTimeProvider] trait object. -/// This function returns the correct [TimeProvider] instance from a raw byte array -/// by checking the days of length field. It also checks the CCSDS time code for correctness. +/// by checking the length of days field. It also checks the CCSDS time code for correctness. /// /// # Example /// @@ -638,11 +634,13 @@ impl TimeProvider { } fn from_unix_generic( - unix_seconds: i64, - subsec_millis: u32, + unix_stamp: &UnixTimestamp, days_len: LengthOfDaySegment, ) -> Result { - let conv_from_dt = ConversionFromUnix::new(unix_seconds, subsec_millis)?; + let conv_from_dt = ConversionFromUnix::new( + unix_stamp.unix_seconds, + unix_stamp.subsecond_millis.unwrap_or(0) as u32, + )?; Self::generic_from_conversion(days_len, conv_from_dt) } @@ -763,10 +761,9 @@ impl TimeProvider { /// [TimestampError::CdsError] if the time is before the CCSDS epoch (01-01-1958 00:00:00) or /// the CCSDS days value exceeds the allowed bit width (24 bits). pub fn from_unix_secs_with_u24_days( - unix_seconds: i64, - subsec_millis: u32, + unix_stamp: &UnixTimestamp, ) -> Result { - Self::from_unix_generic(unix_seconds, subsec_millis, LengthOfDaySegment::Long24Bits) + Self::from_unix_generic(unix_stamp, LengthOfDaySegment::Long24Bits) } /// Create a provider from a [`DateTime`] struct. @@ -849,10 +846,9 @@ impl TimeProvider { /// [TimestampError::CdsError] if the time is before the CCSDS epoch (01-01-1958 00:00:00) or /// the CCSDS days value exceeds the allowed bit width (24 bits). pub fn from_unix_secs_with_u16_days( - unix_seconds: i64, - subsec_millis: u32, + unix_stamp: &UnixTimestamp, ) -> Result { - Self::from_unix_generic(unix_seconds, subsec_millis, LengthOfDaySegment::Short16Bits) + Self::from_unix_generic(unix_stamp, LengthOfDaySegment::Short16Bits) } /// Create a provider from a [`DateTime`] struct. @@ -988,13 +984,13 @@ fn add_for_max_ccsds_days_val( (next_ccsds_days, next_ms_of_day, precision) } -impl CdsTimeStamp for TimeProvider { +impl CdsTimestamp for TimeProvider { fn len_of_day_seg(&self) -> LengthOfDaySegment { LengthOfDaySegment::Short16Bits } } -impl CdsTimeStamp for TimeProvider { +impl CdsTimestamp for TimeProvider { fn len_of_day_seg(&self) -> LengthOfDaySegment { LengthOfDaySegment::Long24Bits } @@ -1759,8 +1755,11 @@ mod tests { fn test_creation_from_unix_stamp_0_u16_days() { let unix_secs = 0; let subsec_millis = 0; - let time_provider = TimeProvider::from_unix_secs_with_u16_days(unix_secs, subsec_millis) - .expect("creating provider from unix stamp failed"); + let time_provider = TimeProvider::from_unix_secs_with_u16_days(&UnixTimestamp::const_new( + unix_secs, + subsec_millis, + )) + .expect("creating provider from unix stamp failed"); assert_eq!(time_provider.ccsds_days, -DAYS_CCSDS_TO_UNIX as u16) } @@ -1768,8 +1767,11 @@ mod tests { fn test_creation_from_unix_stamp_0_u24_days() { let unix_secs = 0; let subsec_millis = 0; - let time_provider = TimeProvider::from_unix_secs_with_u24_days(unix_secs, subsec_millis) - .expect("creating provider from unix stamp failed"); + let time_provider = TimeProvider::from_unix_secs_with_u24_days(&UnixTimestamp::const_new( + unix_secs, + subsec_millis, + )) + .expect("creating provider from unix stamp failed"); assert_eq!(time_provider.ccsds_days, (-DAYS_CCSDS_TO_UNIX) as u32) } @@ -1781,9 +1783,8 @@ mod tests { .and_hms_milli_opt(16, 49, 30, subsec_millis) .unwrap(); let datetime_utc = DateTime::::from_utc(naivedatetime_utc, Utc); - let time_provider = - TimeProvider::from_unix_secs_with_u16_days(datetime_utc.timestamp(), subsec_millis) - .expect("creating provider from unix stamp failed"); + let time_provider = TimeProvider::from_unix_secs_with_u16_days(&datetime_utc.into()) + .expect("creating provider from unix stamp failed"); // https://www.timeanddate.com/date/durationresult.html?d1=01&m1=01&y1=1958&d2=14&m2=01&y2=2023 // Leap years need to be accounted for as well. assert_eq!(time_provider.ccsds_days, 23754); @@ -1799,8 +1800,11 @@ mod tests { fn test_creation_0_ccsds_days() { let unix_secs = DAYS_CCSDS_TO_UNIX as i64 * SECONDS_PER_DAY as i64; let subsec_millis = 0; - let time_provider = TimeProvider::from_unix_secs_with_u16_days(unix_secs, subsec_millis) - .expect("creating provider from unix stamp failed"); + let time_provider = TimeProvider::from_unix_secs_with_u16_days(&UnixTimestamp::const_new( + unix_secs, + subsec_millis, + )) + .expect("creating provider from unix stamp failed"); assert_eq!(time_provider.ccsds_days, 0) } @@ -1808,7 +1812,10 @@ mod tests { fn test_invalid_creation_from_unix_stamp_days_too_large() { let invalid_unix_secs: i64 = (u16::MAX as i64 + 1) * SECONDS_PER_DAY as i64; let subsec_millis = 0; - match TimeProvider::from_unix_secs_with_u16_days(invalid_unix_secs as i64, subsec_millis) { + match TimeProvider::from_unix_secs_with_u16_days(&UnixTimestamp::const_new( + invalid_unix_secs as i64, + subsec_millis, + )) { Ok(_) => { panic!("creation should not succeed") } @@ -1831,7 +1838,10 @@ mod tests { // precisely 31-12-1957 23:59:55 let unix_secs = DAYS_CCSDS_TO_UNIX * SECONDS_PER_DAY as i32 - 5; let subsec_millis = 0; - match TimeProvider::from_unix_secs_with_u16_days(unix_secs as i64, subsec_millis) { + match TimeProvider::from_unix_secs_with_u16_days(&UnixTimestamp::const_new( + unix_secs as i64, + subsec_millis, + )) { Ok(_) => { panic!("creation should not succeed") } diff --git a/src/time/mod.rs b/src/time/mod.rs index 9af0cf5..b5dd984 100644 --- a/src/time/mod.rs +++ b/src/time/mod.rs @@ -241,15 +241,8 @@ pub struct UnixTimestamp { } impl UnixTimestamp { - pub fn new(unix_seconds: i64) -> Self { - Self { - unix_seconds, - subsecond_millis: None, - } - } - /// Returns none if the subsecond millisecond value is larger than 999. - pub fn new_with_subsecond_millis(unix_seconds: i64, subsec_millis: u16) -> Option { + pub fn new(unix_seconds: i64, subsec_millis: u16) -> Option { if subsec_millis > 999 { return None; } @@ -259,6 +252,23 @@ impl UnixTimestamp { }) } + pub const fn const_new(unix_seconds: i64, subsec_millis: u16) -> Self { + if subsec_millis > 999 { + panic!("subsec milliseconds exceeds 999"); + } + Self { + unix_seconds, + subsecond_millis: Some(subsec_millis), + } + } + + pub fn new_only_seconds(unix_seconds: i64) -> Self { + Self { + unix_seconds, + subsecond_millis: None, + } + } + pub fn subsecond_millis(&self) -> Option { self.subsecond_millis } @@ -282,6 +292,22 @@ impl UnixTimestamp { } secs } + + pub fn as_date_time(&self) -> LocalResult> { + Utc.timestamp_opt( + self.unix_seconds, + self.subsecond_millis.unwrap_or(0) as u32 * 10_u32.pow(6), + ) + } +} + +impl From> for UnixTimestamp { + fn from(value: DateTime) -> Self { + Self { + unix_seconds: value.timestamp(), + subsecond_millis: Some(value.timestamp_subsec_millis() as u16), + } + } } #[cfg(all(test, feature = "std"))] @@ -315,17 +341,17 @@ mod tests { #[test] fn basic_unix_stamp_test() { - let stamp = UnixTimestamp::new(-200); + let stamp = UnixTimestamp::new_only_seconds(-200); assert_eq!(stamp.unix_seconds, -200); assert!(stamp.subsecond_millis().is_none()); - let stamp = UnixTimestamp::new(250); + let stamp = UnixTimestamp::new_only_seconds(250); assert_eq!(stamp.unix_seconds, 250); assert!(stamp.subsecond_millis().is_none()); } #[test] fn basic_float_unix_stamp_test() { - let stamp = UnixTimestamp::new_with_subsecond_millis(500, 600).unwrap(); + let stamp = UnixTimestamp::new(500, 600).unwrap(); assert!(stamp.subsecond_millis.is_some()); assert_eq!(stamp.unix_seconds, 500); let subsec_millis = stamp.subsecond_millis().unwrap(); diff --git a/src/tm.rs b/src/tm.rs index 64274b5..7881b27 100644 --- a/src/tm.rs +++ b/src/tm.rs @@ -48,7 +48,7 @@ pub mod zc { pub struct PusTmSecHeader<'slice> { pub(crate) zc_header: PusTmSecHeaderWithoutTimestamp, - pub(crate) timestamp: &'slice [u8], + pub(crate) timestamp: Option<&'slice [u8]>, } impl TryFrom> for PusTmSecHeaderWithoutTimestamp { @@ -115,20 +115,17 @@ pub struct PusTmSecondaryHeader<'stamp> { pub subservice: u8, pub msg_counter: u16, pub dest_id: u16, - pub time_stamp: &'stamp [u8], + pub timestamp: Option<&'stamp [u8]>, } impl<'stamp> PusTmSecondaryHeader<'stamp> { - pub fn new_simple(service: u8, subservice: u8, time_stamp: &'stamp [u8]) -> Self { - PusTmSecondaryHeader { - pus_version: PusVersion::PusC, - sc_time_ref_status: 0, - service, - subservice, - msg_counter: 0, - dest_id: 0, - time_stamp, - } + pub fn new_simple(service: u8, subservice: u8, timestamp: &'stamp [u8]) -> Self { + Self::new(service, subservice, 0, 0, Some(timestamp)) + } + + /// Like [new_simple] but without a timestamp. + pub fn new_simple_no_timestamp(service: u8, subservice: u8) -> Self { + Self::new(service, subservice, 0, 0, None) } pub fn new( @@ -136,7 +133,7 @@ impl<'stamp> PusTmSecondaryHeader<'stamp> { subservice: u8, msg_counter: u16, dest_id: u16, - time_stamp: &'stamp [u8], + timestamp: Option<&'stamp [u8]>, ) -> Self { PusTmSecondaryHeader { pus_version: PusVersion::PusC, @@ -145,7 +142,7 @@ impl<'stamp> PusTmSecondaryHeader<'stamp> { subservice, msg_counter, dest_id, - time_stamp, + timestamp, } } } @@ -187,7 +184,7 @@ impl<'slice> TryFrom> for PusTmSecondaryHeader<'slice subservice: sec_header.zc_header.subservice(), msg_counter: sec_header.zc_header.msg_counter(), dest_id: sec_header.zc_header.dest_id(), - time_stamp: sec_header.timestamp, + timestamp: sec_header.timestamp, }) } } @@ -257,15 +254,17 @@ impl<'src_data> PusTm<'src_data> { pub fn len_packed(&self) -> usize { let mut length = PUS_TM_MIN_LEN_WITHOUT_SOURCE_DATA; - length += self.sec_header.time_stamp.len(); + if let Some(timestamp) = self.sec_header.timestamp { + length += timestamp.len(); + } if let Some(src_data) = self.source_data { length += src_data.len(); } length } - pub fn time_stamp(&self) -> &'src_data [u8] { - self.sec_header.time_stamp + pub fn timestamp(&self) -> Option<&'src_data [u8]> { + self.sec_header.timestamp } pub fn source_data(&self) -> Option<&'src_data [u8]> { @@ -304,7 +303,9 @@ impl<'src_data> PusTm<'src_data> { digest.update(sph_zc.as_bytes()); let pus_tc_header = zc::PusTmSecHeaderWithoutTimestamp::try_from(self.sec_header).unwrap(); digest.update(pus_tc_header.as_bytes()); - digest.update(self.sec_header.time_stamp); + if let Some(stamp) = self.sec_header.timestamp { + digest.update(stamp); + } if let Some(src_data) = self.source_data { digest.update(src_data); } @@ -337,9 +338,11 @@ impl<'src_data> PusTm<'src_data> { .write_to_bytes(&mut slice[curr_idx..curr_idx + sec_header_len]) .ok_or(ByteConversionError::ZeroCopyToError)?; curr_idx += sec_header_len; - let timestamp_len = self.sec_header.time_stamp.len(); - slice[curr_idx..curr_idx + timestamp_len].copy_from_slice(self.sec_header.time_stamp); - curr_idx += timestamp_len; + if let Some(timestamp) = self.sec_header.timestamp { + let timestamp_len = timestamp.len(); + slice[curr_idx..curr_idx + timestamp_len].copy_from_slice(timestamp); + curr_idx += timestamp_len; + } if let Some(src_data) = self.source_data { slice[curr_idx..curr_idx + src_data.len()].copy_from_slice(src_data); curr_idx += src_data.len(); @@ -361,8 +364,10 @@ impl<'src_data> PusTm<'src_data> { #[cfg_attr(doc_cfg, doc(cfg(feature = "alloc")))] pub fn append_to_vec(&self, vec: &mut Vec) -> Result { let sph_zc = crate::zc::SpHeader::from(self.sp_header); - let mut appended_len = - PUS_TM_MIN_LEN_WITHOUT_SOURCE_DATA + self.sec_header.time_stamp.len(); + let mut appended_len = PUS_TM_MIN_LEN_WITHOUT_SOURCE_DATA; + if let Some(timestamp) = self.sec_header.timestamp { + appended_len += timestamp.len(); + } if let Some(src_data) = self.source_data { appended_len += src_data.len(); }; @@ -374,8 +379,10 @@ impl<'src_data> PusTm<'src_data> { let sec_header = zc::PusTmSecHeaderWithoutTimestamp::try_from(self.sec_header).unwrap(); vec.extend_from_slice(sec_header.as_bytes()); ser_len += sec_header.as_bytes().len(); - vec.extend_from_slice(self.sec_header.time_stamp); - ser_len += self.sec_header.time_stamp.len(); + if let Some(timestamp) = self.sec_header.timestamp { + ser_len += timestamp.len(); + vec.extend_from_slice(timestamp); + } if let Some(src_data) = self.source_data { vec.extend_from_slice(src_data); ser_len += src_data.len(); @@ -414,9 +421,13 @@ impl<'src_data> PusTm<'src_data> { ) .ok_or(ByteConversionError::ZeroCopyFromError)?; current_idx += PUC_TM_MIN_SEC_HEADER_LEN; + let mut timestamp = None; + if timestamp_len > 0 { + timestamp = Some(&slice[current_idx..current_idx + timestamp_len]); + } let zc_sec_header_wrapper = zc::PusTmSecHeader { zc_header: sec_header_zc, - timestamp: &slice[current_idx..current_idx + timestamp_len], + timestamp, }; current_idx += timestamp_len; let raw_data = &slice[0..total_len]; @@ -473,33 +484,33 @@ mod tests { use crate::ecss::PusVersion::PusC; use crate::SpHeader; - fn base_ping_reply_full_ctor(time_stamp: &[u8]) -> PusTm { + fn base_ping_reply_full_ctor(timestamp: &[u8]) -> PusTm { let mut sph = SpHeader::tm_unseg(0x123, 0x234, 0).unwrap(); - let tc_header = PusTmSecondaryHeader::new_simple(17, 2, &time_stamp); + let tc_header = PusTmSecondaryHeader::new_simple(17, 2, ×tamp); PusTm::new(&mut sph, tc_header, None, true) } - fn base_hk_reply<'a>(time_stamp: &'a [u8], src_data: &'a [u8]) -> PusTm<'a> { + fn base_hk_reply<'a>(timestamp: &'a [u8], src_data: &'a [u8]) -> PusTm<'a> { let mut sph = SpHeader::tm_unseg(0x123, 0x234, 0).unwrap(); - let tc_header = PusTmSecondaryHeader::new_simple(3, 5, &time_stamp); + let tc_header = PusTmSecondaryHeader::new_simple(3, 5, ×tamp); PusTm::new(&mut sph, tc_header, Some(src_data), true) } - fn dummy_time_stamp() -> &'static [u8] { + fn dummy_timestamp() -> &'static [u8] { return &[0, 1, 2, 3, 4, 5, 6]; } #[test] fn test_basic() { - let time_stamp = dummy_time_stamp(); - let pus_tm = base_ping_reply_full_ctor(&time_stamp); - verify_ping_reply(&pus_tm, false, 22, dummy_time_stamp()); + let timestamp = dummy_timestamp(); + let pus_tm = base_ping_reply_full_ctor(×tamp); + verify_ping_reply(&pus_tm, false, 22, dummy_timestamp()); } #[test] fn test_serialization_no_source_data() { - let time_stamp = dummy_time_stamp(); - let pus_tm = base_ping_reply_full_ctor(&time_stamp); + let timestamp = dummy_timestamp(); + let pus_tm = base_ping_reply_full_ctor(×tamp); let mut buf: [u8; 32] = [0; 32]; let ser_len = pus_tm .write_to_bytes(&mut buf) @@ -511,7 +522,7 @@ mod tests { #[test] fn test_serialization_with_source_data() { let src_data = [1, 2, 3]; - let hk_reply = base_hk_reply(dummy_time_stamp(), &src_data); + let hk_reply = base_hk_reply(dummy_timestamp(), &src_data); let mut buf: [u8; 32] = [0; 32]; let ser_len = hk_reply .write_to_bytes(&mut buf) @@ -524,8 +535,8 @@ mod tests { #[test] fn test_setters() { - let time_stamp = dummy_time_stamp(); - let mut pus_tm = base_ping_reply_full_ctor(&time_stamp); + let timestamp = dummy_timestamp(); + let mut pus_tm = base_ping_reply_full_ctor(×tamp); pus_tm.set_sc_time_ref_status(0b1010); pus_tm.set_dest_id(0x7fff); pus_tm.set_msg_counter(0x1f1f); @@ -538,8 +549,8 @@ mod tests { #[test] fn test_deserialization_no_source_data() { - let time_stamp = dummy_time_stamp(); - let pus_tm = base_ping_reply_full_ctor(&time_stamp); + let timestamp = dummy_timestamp(); + let pus_tm = base_ping_reply_full_ctor(×tamp); let mut buf: [u8; 32] = [0; 32]; let ser_len = pus_tm .write_to_bytes(&mut buf) @@ -547,13 +558,13 @@ mod tests { assert_eq!(ser_len, 22); let (tm_deserialized, size) = PusTm::from_bytes(&buf, 7).expect("Deserialization failed"); assert_eq!(ser_len, size); - verify_ping_reply(&tm_deserialized, false, 22, dummy_time_stamp()); + verify_ping_reply(&tm_deserialized, false, 22, dummy_timestamp()); } #[test] fn test_manual_field_update() { let mut sph = SpHeader::tm_unseg(0x123, 0x234, 0).unwrap(); - let tc_header = PusTmSecondaryHeader::new_simple(17, 2, dummy_time_stamp()); + let tc_header = PusTmSecondaryHeader::new_simple(17, 2, dummy_timestamp()); let mut tm = PusTm::new(&mut sph, tc_header, None, false); tm.calc_crc_on_serialization = false; assert_eq!(tm.data_len(), 0x00); @@ -573,8 +584,8 @@ mod tests { #[test] fn test_target_buf_too_small() { - let time_stamp = dummy_time_stamp(); - let pus_tm = base_ping_reply_full_ctor(&time_stamp); + let timestamp = dummy_timestamp(); + let pus_tm = base_ping_reply_full_ctor(×tamp); let mut buf: [u8; 16] = [0; 16]; let res = pus_tm.write_to_bytes(&mut buf); assert!(res.is_err()); @@ -597,8 +608,8 @@ mod tests { #[test] #[cfg(feature = "alloc")] fn test_append_to_vec() { - let time_stamp = dummy_time_stamp(); - let pus_tm = base_ping_reply_full_ctor(&time_stamp); + let timestamp = dummy_timestamp(); + let pus_tm = base_ping_reply_full_ctor(×tamp); let mut vec = Vec::new(); let res = pus_tm.append_to_vec(&mut vec); assert!(res.is_ok()); @@ -610,7 +621,7 @@ mod tests { #[cfg(feature = "alloc")] fn test_append_to_vec_with_src_data() { let src_data = [1, 2, 3]; - let hk_reply = base_hk_reply(dummy_time_stamp(), &src_data); + let hk_reply = base_hk_reply(dummy_timestamp(), &src_data); let mut vec = Vec::new(); vec.push(4); let res = hk_reply.append_to_vec(&mut vec); @@ -639,7 +650,7 @@ mod tests { assert_eq!(buf[11], 0x00); assert_eq!(buf[12], 0x00); // Timestamp - assert_eq!(&buf[13..20], dummy_time_stamp()); + assert_eq!(&buf[13..20], dummy_timestamp()); let mut digest = CRC_CCITT_FALSE.digest(); digest.update(&buf[0..20]); let crc16 = digest.finalize(); @@ -651,14 +662,14 @@ mod tests { tm: &PusTm, has_user_data: bool, exp_full_len: usize, - exp_time_stamp: &[u8], + exp_timestamp: &[u8], ) { assert!(tm.is_tm()); assert_eq!(PusPacket::service(tm), 17); assert_eq!(PusPacket::subservice(tm), 2); assert!(tm.sec_header_flag()); assert_eq!(tm.len_packed(), exp_full_len); - assert_eq!(tm.time_stamp(), exp_time_stamp); + assert_eq!(tm.timestamp().unwrap(), exp_timestamp); if has_user_data { assert!(!tm.user_data().is_none()); }