From 1d9329ad6358f27c1550e707924da8dcfc07095c Mon Sep 17 00:00:00 2001 From: Robin Mueller Date: Sat, 10 Dec 2022 17:39:15 +0100 Subject: [PATCH] this should cover most basic cases --- src/time/cuc.rs | 128 +++++++++++++++++++++++++++++++++++++++++++++--- 1 file changed, 120 insertions(+), 8 deletions(-) diff --git a/src/time/cuc.rs b/src/time/cuc.rs index a949616..6a5c491 100644 --- a/src/time/cuc.rs +++ b/src/time/cuc.rs @@ -531,9 +531,9 @@ mod tests { #[test] fn test_basic_zero_epoch() { - let zero_cuc = TimeProviderCcsdsEpoch::new_generic(WidthCounterPair(4, 0), None); - assert!(zero_cuc.is_ok()); - let zero_cuc = zero_cuc.unwrap(); + let zero_cuc = TimeProviderCcsdsEpoch::new(0); + assert_eq!(zero_cuc.len_as_bytes(), 5); + assert_eq!(zero_cuc.ccdsd_time_code(), CcsdsTimeCodes::CucCcsdsEpoch); let counter = zero_cuc.width_counter_pair(); assert_eq!(counter.0, 4); assert_eq!(counter.1, 0); @@ -558,6 +558,8 @@ mod tests { let zero_cuc = zero_cuc.unwrap(); let res = zero_cuc.write_to_bytes(&mut buf); assert!(res.is_ok()); + assert_eq!(zero_cuc.len_as_bytes(), 5); + assert_eq!(pfield_len(buf[0]), 1); let written = res.unwrap(); assert_eq!(written, 5); assert_eq!((buf[0] >> 7) & 0b1, 0); @@ -571,6 +573,21 @@ mod tests { assert_eq!(buf[5], 0); } + #[test] + fn test_datetime_now() { + let now = Utc::now(); + let cuc_now = TimeProviderCcsdsEpoch::from_now(FractionalResolution::SixtyNs); + assert!(cuc_now.is_ok()); + let cuc_now = cuc_now.unwrap(); + let dt_opt = cuc_now.date_time(); + assert!(dt_opt.is_some()); + let dt = dt_opt.unwrap(); + let diff = dt - now; + assert!(diff.num_milliseconds() < 1000); + println!("datetime from cuc: {}", dt); + println!("datetime now: {}", now); + } + #[test] fn test_read_no_fractions() { let mut buf: [u8; 16] = [0; 16]; @@ -586,7 +603,7 @@ mod tests { #[test] fn invalid_read_len() { - let buf: [u8; 8] = [0; 8]; + let mut buf: [u8; 16] = [0; 16]; for i in 0..2 { let res = TimeProviderCcsdsEpoch::from_bytes(&buf[0..i]); assert!(res.is_err()); @@ -598,8 +615,98 @@ mod tests { assert_eq!(e.expected, 2); } } + let large_stamp = TimeProviderCcsdsEpoch::new_with_fine_fractions(22, 300).unwrap(); + large_stamp.write_to_bytes(&mut buf).unwrap(); + for i in 2..large_stamp.len_as_bytes() - 1 { + let res = TimeProviderCcsdsEpoch::from_bytes(&buf[0..i]); + assert!(res.is_err()); + let err = res.unwrap_err(); + if let TimestampError::ByteConversionError(ByteConversionError::FromSliceTooSmall(e)) = + err + { + assert_eq!(e.found, i); + assert_eq!(e.expected, large_stamp.len_as_bytes()); + } + } } + #[test] + fn write_and_read_tiny_stamp() { + let mut buf = [0; 2]; + let cuc = TimeProviderCcsdsEpoch::new_generic(WidthCounterPair(1, 200), None); + assert!(cuc.is_ok()); + let cuc = cuc.unwrap(); + assert_eq!(cuc.len_as_bytes(), 2); + let res = cuc.write_to_bytes(&mut buf); + assert!(res.is_ok()); + let written = res.unwrap(); + assert_eq!(written, 2); + assert_eq!(buf[1], 200); + let cuc_read_back = TimeProviderCcsdsEpoch::from_bytes(&buf); + assert!(cuc_read_back.is_ok()); + let cuc_read_back = cuc_read_back.unwrap(); + assert_eq!(cuc_read_back, cuc); + } + + #[test] + fn write_slightly_larger_stamp() { + let mut buf = [0; 4]; + let cuc = TimeProviderCcsdsEpoch::new_generic(WidthCounterPair(2, 40000), None); + assert!(cuc.is_ok()); + let cuc = cuc.unwrap(); + assert_eq!(cuc.len_as_bytes(), 3); + let res = cuc.write_to_bytes(&mut buf); + assert!(res.is_ok()); + let written = res.unwrap(); + assert_eq!(written, 3); + assert_eq!(u16::from_be_bytes(buf[1..3].try_into().unwrap()), 40000); + let cuc_read_back = TimeProviderCcsdsEpoch::from_bytes(&buf); + assert!(cuc_read_back.is_ok()); + let cuc_read_back = cuc_read_back.unwrap(); + assert_eq!(cuc_read_back, cuc); + } + + #[test] + fn invalid_buf_len_for_read() {} + #[test] + fn write_read_three_byte_cntr_stamp() { + let mut buf = [0; 4]; + let cuc = TimeProviderCcsdsEpoch::new_generic(WidthCounterPair(3, 2_u32.pow(24) - 2), None); + assert!(cuc.is_ok()); + let cuc = cuc.unwrap(); + assert_eq!(cuc.len_as_bytes(), 4); + let res = cuc.write_to_bytes(&mut buf); + assert!(res.is_ok()); + let written = res.unwrap(); + assert_eq!(written, 4); + let mut temp_buf = [0; 4]; + temp_buf[1..4].copy_from_slice(&buf[1..4]); + assert_eq!(u32::from_be_bytes(temp_buf), 2_u32.pow(24) - 2); + let cuc_read_back = TimeProviderCcsdsEpoch::from_bytes(&buf); + assert!(cuc_read_back.is_ok()); + let cuc_read_back = cuc_read_back.unwrap(); + assert_eq!(cuc_read_back, cuc); + } + + #[test] + fn test_write_invalid_buf() { + let mut buf: [u8; 16] = [0; 16]; + let res = TimeProviderCcsdsEpoch::new_with_fine_fractions(0, 0); + let cuc = res.unwrap(); + for i in 0..cuc.len_as_bytes() - 1 { + let err = cuc.write_to_bytes(&mut buf[0..i]); + assert!(err.is_err()); + let err = err.unwrap_err(); + if let TimestampError::ByteConversionError(ByteConversionError::ToSliceTooSmall(e)) = + err + { + assert_eq!(e.expected, cuc.len_as_bytes()); + assert_eq!(e.found, i); + } else { + panic!("unexpected error: {}", err); + } + } + } #[test] fn invalid_ccsds_stamp_type() { let mut buf: [u8; 16] = [0; 16]; @@ -628,7 +735,10 @@ mod tests { assert_eq!(written, 6); assert_eq!(buf[5], 120); assert_eq!(buf[6], 0); - assert_eq!(u32::from_be_bytes(buf[1..5].try_into().unwrap()), 0x30201060); + assert_eq!( + u32::from_be_bytes(buf[1..5].try_into().unwrap()), + 0x30201060 + ); } #[test] @@ -637,7 +747,7 @@ mod tests { let cuc = TimeProviderCcsdsEpoch::new_with_coarse_fractions(0x30201060, 120); let res = cuc.write_to_bytes(&mut buf); assert!(res.is_ok()); - let res= TimeProviderCcsdsEpoch::from_bytes(&buf); + let res = TimeProviderCcsdsEpoch::from_bytes(&buf); assert!(res.is_ok()); let read_back = res.unwrap(); assert_eq!(read_back, cuc); @@ -670,7 +780,8 @@ mod tests { #[test] fn test_write_with_fine_fractions() { let mut buf: [u8; 16] = [0; 16]; - let cuc = TimeProviderCcsdsEpoch::new_with_fine_fractions(0x30303030, u16::MAX as u32 + 60000); + let cuc = + TimeProviderCcsdsEpoch::new_with_fine_fractions(0x30303030, u16::MAX as u32 + 60000); assert!(cuc.is_ok()); let cuc = cuc.unwrap(); let res = cuc.write_to_bytes(&mut buf); @@ -685,7 +796,8 @@ mod tests { #[test] fn test_read_with_fine_fractions() { let mut buf: [u8; 16] = [0; 16]; - let cuc = TimeProviderCcsdsEpoch::new_with_fine_fractions(0x30303030, u16::MAX as u32 + 60000); + let cuc = + TimeProviderCcsdsEpoch::new_with_fine_fractions(0x30303030, u16::MAX as u32 + 60000); assert!(cuc.is_ok()); let cuc = cuc.unwrap(); let res = cuc.write_to_bytes(&mut buf);