From 3650507715cb48a9914a3baafce2f46c3a7eac84 Mon Sep 17 00:00:00 2001 From: Robin Mueller Date: Wed, 6 Dec 2023 15:17:03 +0100 Subject: [PATCH] some more serde tests --- mod.rs | 0 src/cfdp/mod.rs | 27 +++++++++++++-------------- src/cfdp/pdu/ack.rs | 7 +++---- src/cfdp/pdu/eof.rs | 11 +++++++++++ src/cfdp/pdu/finished.rs | 17 +++++++++++++++++ src/ecss/mod.rs | 8 ++++++++ src/ecss/tm.rs | 40 +++++++++++++++++++++++++++++++++++++++- src/lib.rs | 17 +++++++++++++++-- 8 files changed, 106 insertions(+), 21 deletions(-) create mode 100644 mod.rs diff --git a/mod.rs b/mod.rs new file mode 100644 index 0000000..e69de29 diff --git a/src/cfdp/mod.rs b/src/cfdp/mod.rs index 0dc05da..33ee333 100644 --- a/src/cfdp/mod.rs +++ b/src/cfdp/mod.rs @@ -238,8 +238,7 @@ impl Error for TlvLvError { mod tests { use super::*; #[cfg(feature = "serde")] - use postcard::{from_bytes, to_allocvec}; - + use crate::tests::generic_serde_test; #[test] fn test_crc_from_bool() { @@ -268,26 +267,26 @@ mod tests { } #[test] - #[cfg(feature="serde")] + #[cfg(feature = "serde")] fn test_serde_impl_pdu_type() { - let pdu_type = PduType::FileData; - let output = to_allocvec(&pdu_type).unwrap(); - assert_eq!(from_bytes::(&output).unwrap(), pdu_type); + generic_serde_test(PduType::FileData); } #[test] - #[cfg(feature="serde")] + #[cfg(feature = "serde")] fn test_serde_impl_direction() { - let direction = Direction::TowardsReceiver; - let output = to_allocvec(&direction).unwrap(); - assert_eq!(from_bytes::(&output).unwrap(), direction); + generic_serde_test(Direction::TowardsReceiver); } #[test] - #[cfg(feature="serde")] + #[cfg(feature = "serde")] fn test_serde_impl_transmission_mode() { - let mode = TransmissionMode::Unacknowledged; - let output = to_allocvec(&mode).unwrap(); - assert_eq!(from_bytes::(&output).unwrap(), mode); + generic_serde_test(TransmissionMode::Unacknowledged); + } + + #[test] + #[cfg(feature = "serde")] + fn test_serde_fault_handler_code() { + generic_serde_test(FaultHandlerCode::NoticeOfCancellation); } } diff --git a/src/cfdp/pdu/ack.rs b/src/cfdp/pdu/ack.rs index 0e6708d..997f40b 100644 --- a/src/cfdp/pdu/ack.rs +++ b/src/cfdp/pdu/ack.rs @@ -201,7 +201,7 @@ mod tests { use super::*; #[cfg(feature = "serde")] - use postcard::{from_bytes, to_allocvec}; + use crate::tests::generic_serde_test; fn verify_state(ack_pdu: &AckPdu, expected_crc_flag: CrcFlag, expected_dir: Direction) { assert_eq!(ack_pdu.condition_code(), ConditionCode::NoError); @@ -320,7 +320,7 @@ mod tests { } #[test] - #[cfg(feature="serde")] + #[cfg(feature = "serde")] fn test_ack_pdu_serialization() { let pdu_conf = common_pdu_conf(CrcFlag::WithCrc, LargeFileFlag::Normal); let pdu_header = PduHeader::new_no_file_data(pdu_conf, 0); @@ -329,7 +329,6 @@ mod tests { ConditionCode::NoError, TransactionStatus::Active, ); - let output = to_allocvec(&ack_pdu).unwrap(); - assert_eq!(from_bytes::(&output).unwrap(), ack_pdu); + generic_serde_test(ack_pdu); } } diff --git a/src/cfdp/pdu/eof.rs b/src/cfdp/pdu/eof.rs index 61aa4d0..af30e9c 100644 --- a/src/cfdp/pdu/eof.rs +++ b/src/cfdp/pdu/eof.rs @@ -168,6 +168,8 @@ mod tests { }; use crate::cfdp::pdu::{FileDirectiveType, PduHeader}; use crate::cfdp::{ConditionCode, CrcFlag, LargeFileFlag, PduType, TransmissionMode}; + #[cfg(feature = "serde")] + use crate::tests::generic_serde_test; fn verify_state(&eof_pdu: &EofPdu, file_flag: LargeFileFlag) { assert_eq!(eof_pdu.file_checksum(), 0x01020304); @@ -283,4 +285,13 @@ mod tests { verify_state(&eof_pdu, LargeFileFlag::Large); assert_eq!(eof_pdu.len_written(), pdu_header.header_len() + 2 + 8 + 4); } + + #[test] + #[cfg(feature = "serde")] + fn test_eof_serde() { + let pdu_conf = common_pdu_conf(CrcFlag::NoCrc, LargeFileFlag::Normal); + let pdu_header = PduHeader::new_no_file_data(pdu_conf, 0); + let eof_pdu = EofPdu::new_no_error(pdu_header, 0x01020304, 12); + generic_serde_test(eof_pdu); + } } diff --git a/src/cfdp/pdu/finished.rs b/src/cfdp/pdu/finished.rs index ef9b7d4..1df15f5 100644 --- a/src/cfdp/pdu/finished.rs +++ b/src/cfdp/pdu/finished.rs @@ -276,6 +276,8 @@ mod tests { }; use crate::cfdp::pdu::{FileDirectiveType, PduHeader}; use crate::cfdp::{ConditionCode, CrcFlag, Direction, LargeFileFlag, TransmissionMode}; + #[cfg(feature = "serde")] + use postcard::{from_bytes, to_allocvec}; fn generic_finished_pdu( crc_flag: CrcFlag, @@ -491,4 +493,19 @@ mod tests { #[test] fn test_deserialization_with_fs_responses() {} + + #[test] + #[cfg(feature = "serde")] + fn test_finished_serialization_serde() { + let finished_pdu = generic_finished_pdu( + CrcFlag::NoCrc, + LargeFileFlag::Normal, + DeliveryCode::Complete, + FileStatus::Retained, + ); + + let output = to_allocvec(&finished_pdu).unwrap(); + let output_converted_back: FinishedPdu = from_bytes(&output).unwrap(); + assert_eq!(output_converted_back, finished_pdu); + } } diff --git a/src/ecss/mod.rs b/src/ecss/mod.rs index 3dd3ad4..533e2b3 100644 --- a/src/ecss/mod.rs +++ b/src/ecss/mod.rs @@ -382,6 +382,8 @@ mod tests { use crate::ByteConversionError; use super::*; + #[cfg(feature = "serde")] + use crate::tests::generic_serde_test; #[test] fn test_enum_u8() { @@ -492,4 +494,10 @@ mod tests { let pfc = RealPfc::try_from(pfc_raw).unwrap(); assert_eq!(pfc, RealPfc::Double); } + + #[test] + #[cfg(feature = "serde")] + fn test_serde_pus_service_id() { + generic_serde_test(PusServiceId::Verification); + } } diff --git a/src/ecss/tm.rs b/src/ecss/tm.rs index bc831db..40ee9c8 100644 --- a/src/ecss/tm.rs +++ b/src/ecss/tm.rs @@ -860,7 +860,10 @@ impl<'raw_data> PusTmReader<'raw_data> { impl PartialEq for PusTmReader<'_> { fn eq(&self, other: &Self) -> bool { - self.raw_data == other.raw_data + self.sec_header == other.sec_header + && self.source_data == other.source_data + && self.sp_header == other.sp_header + && self.crc16 == other.crc16 } } @@ -997,7 +1000,11 @@ mod tests { use super::*; use crate::ecss::PusVersion::PusC; use crate::time::cds::TimeProvider; + #[cfg(feature = "serde")] + use crate::time::CcsdsTimeProvider; use crate::SpHeader; + #[cfg(feature = "serde")] + use postcard::{from_bytes, to_allocvec}; fn base_ping_reply_full_ctor(timestamp: &[u8]) -> PusTmCreator { let mut sph = SpHeader::tm_unseg(0x123, 0x234, 0).unwrap(); @@ -1372,4 +1379,35 @@ mod tests { panic!("unexpected error {tm_error}") } } + + #[test] + #[cfg(feature = "serde")] + fn test_serialization_creator_serde() { + let mut sph = SpHeader::tm_unseg(0x123, 0x234, 0).unwrap(); + let time_provider = TimeProvider::new_with_u16_days(0, 0); + let mut stamp_buf: [u8; 8] = [0; 8]; + let pus_tm = + PusTmCreator::new_simple(&mut sph, 17, 2, &time_provider, &mut stamp_buf, &[], true) + .unwrap(); + + let output = to_allocvec(&pus_tm).unwrap(); + let output_converted_back: PusTmCreator = from_bytes(&output).unwrap(); + assert_eq!(output_converted_back, pus_tm); + } + + #[test] + #[cfg(feature = "serde")] + fn test_serialization_reader_serde() { + let mut sph = SpHeader::tm_unseg(0x123, 0x234, 0).unwrap(); + let time_provider = TimeProvider::new_with_u16_days(0, 0); + let mut stamp_buf: [u8; 8] = [0; 8]; + let pus_tm = + PusTmCreator::new_simple(&mut sph, 17, 2, &time_provider, &mut stamp_buf, &[], true) + .unwrap(); + let pus_tm_vec = pus_tm.to_vec().unwrap(); + let (tm_reader, _) = PusTmReader::new(&pus_tm_vec, time_provider.len_as_bytes()).unwrap(); + let output = to_allocvec(&tm_reader).unwrap(); + let output_converted_back: PusTmReader = from_bytes(&output).unwrap(); + assert_eq!(output_converted_back, tm_reader); + } } diff --git a/src/lib.rs b/src/lib.rs index 7a93459..36e6b2e 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -749,7 +749,7 @@ pub mod zc { } #[cfg(all(test, feature = "std"))] -mod tests { +pub(crate) mod tests { use std::collections::HashSet; #[cfg(feature = "serde")] @@ -759,9 +759,13 @@ mod tests { }; use crate::{SequenceFlags, SpHeader}; use alloc::vec; + #[cfg(feature = "serde")] + use core::fmt::Debug; use num_traits::pow; #[cfg(feature = "serde")] use postcard::{from_bytes, to_allocvec}; + #[cfg(feature = "serde")] + use serde::{de::DeserializeOwned, Serialize}; const CONST_SP: SpHeader = SpHeader::new( PacketId::const_tc(true, 0x36), @@ -771,10 +775,19 @@ mod tests { const PACKET_ID_TM: PacketId = PacketId::const_tm(true, 0x22); + #[cfg(feature = "serde")] + pub(crate) fn generic_serde_test( + value: T, + ) { + let output: alloc::vec::Vec = to_allocvec(&value).unwrap(); + let output_converted_back: T = from_bytes(&output).unwrap(); + assert_eq!(output_converted_back, value); + } + #[test] fn verify_const_packet_id() { assert_eq!(PACKET_ID_TM.apid(), 0x22); - assert_eq!(PACKET_ID_TM.sec_header_flag, true); + assert!(PACKET_ID_TM.sec_header_flag); assert_eq!(PACKET_ID_TM.ptype, PacketType::Tm); let const_tc_id = PacketId::const_tc(true, 0x23); assert_eq!(const_tc_id.ptype, PacketType::Tc);