add some more tests

satrs/Cargo.toml

@@ -15,6 +15,7 @@ categories = ["aerospace", "aerospace::space-protocols", "no-std", "hardware-sup
 [dependencies]
 delegate = ">0.7, <=0.10"
 paste = "1"
+derive-new = "0.6"
 smallvec = "1"
 crc = "3"
 

satrs/src/pus/event.rs

@@ -407,7 +407,7 @@ mod tests {
             severity_to_subservice(severity) as u8
         );
         assert_eq!(tm_info.common.dest_id, 0);
-        assert_eq!(tm_info.common.time_stamp, time_stamp_empty);
+        assert_eq!(tm_info.common.timestamp, time_stamp_empty);
         assert_eq!(tm_info.common.msg_counter, 0);
         assert_eq!(tm_info.common.apid, EXAMPLE_APID);
         assert_eq!(tm_info.event, event);

satrs/src/pus/event_man.rs

@@ -315,6 +315,12 @@ pub mod alloc_mod {
 }
 #[cfg(test)]
 mod tests {
+    use alloc::string::{String, ToString};
+    use alloc::vec;
+    use spacepackets::ecss::event::Subservice;
+    use spacepackets::ecss::tm::PusTmReader;
+    use spacepackets::ecss::PusPacket;
+
     use super::*;
     use crate::request::UniqueApidTargetId;
     use crate::{events::SeverityInfo, tmtc::PacketAsVec};
@@ -392,7 +398,68 @@ mod tests {
     }
 
     #[test]
-    fn test_event_with_generic_params() {
+    fn test_event_with_generic_string_param() {
+        let event_man = create_basic_man_1();
+        let mut small_data_buf = [0; 128];
+        let param_data = "hello world";
+        let (event_tx, event_rx) = mpsc::channel::<PacketAsVec>();
+        let res = event_man.generate_pus_event_tm_generic_with_generic_params(
+            &event_tx,
+            &EMPTY_STAMP,
+            INFO_EVENT.into(),
+            &mut small_data_buf,
+            Some(&param_data.to_string().into()),
+        );
+        assert!(res.is_ok());
+        let res = res.unwrap();
+        assert!(res.event_was_enabled);
+        assert!(res.params_were_propagated);
+        let event_tm = event_rx.try_recv().expect("no event received");
+        let (tm, _) = PusTmReader::new(&event_tm.packet, 7).expect("reading TM failed");
+        assert_eq!(tm.service(), 5);
+        assert_eq!(tm.subservice(), Subservice::TmInfoReport as u8);
+        assert_eq!(tm.user_data().len(), 4 + param_data.len());
+        let u32_event = u32::from_be_bytes(tm.user_data()[0..4].try_into().unwrap());
+        assert_eq!(u32_event, INFO_EVENT.raw());
+        let string_data = String::from_utf8_lossy(&tm.user_data()[4..]);
+        assert_eq!(string_data, param_data);
+    }
+
+    #[test]
+    fn test_event_with_generic_vec_param() {
+        let event_man = create_basic_man_1();
+        let mut small_data_buf = [0; 128];
+        let param_data = vec![1, 2, 3, 4];
+        let (event_tx, event_rx) = mpsc::channel::<PacketAsVec>();
+        let res = event_man.generate_pus_event_tm_generic_with_generic_params(
+            &event_tx,
+            &EMPTY_STAMP,
+            INFO_EVENT.into(),
+            &mut small_data_buf,
+            Some(&param_data.clone().into()),
+        );
+        assert!(res.is_ok());
+        let res = res.unwrap();
+        assert!(res.event_was_enabled);
+        assert!(res.params_were_propagated);
+        let event_tm = event_rx.try_recv().expect("no event received");
+        let (tm, _) = PusTmReader::new(&event_tm.packet, 7).expect("reading TM failed");
+        assert_eq!(tm.service(), 5);
+        assert_eq!(tm.subservice(), Subservice::TmInfoReport as u8);
+        assert_eq!(tm.user_data().len(), 4 + param_data.len());
+        let u32_event = u32::from_be_bytes(tm.user_data()[0..4].try_into().unwrap());
+        assert_eq!(u32_event, INFO_EVENT.raw());
+        let vec_data = tm.user_data()[4..].to_vec();
+        assert_eq!(vec_data, param_data);
+    }
+
+    #[test]
+    fn test_event_with_generic_store_param_not_propagated() {
+        // TODO: Test this.
+    }
+
+    #[test]
+    fn test_event_with_generic_heapless_param() {
         // TODO: Test this.
     }
 }

satrs/src/pus/mod.rs

@@ -1258,6 +1258,7 @@ pub mod tests {
 
     use alloc::collections::VecDeque;
     use alloc::vec::Vec;
+    use derive_new::new;
     use satrs_shared::res_code::ResultU16;
     use spacepackets::ecss::tc::{PusTcCreator, PusTcReader};
     use spacepackets::ecss::tm::{GenericPusTmSecondaryHeader, PusTmCreator, PusTmReader};
@@ -1284,36 +1285,46 @@ pub mod tests {
         pub seq_count: u16,
         pub msg_counter: u16,
         pub dest_id: u16,
-        pub time_stamp: [u8; 7],
+        pub timestamp: Vec<u8>,
     }
 
     impl CommonTmInfo {
-        pub fn new_zero_seq_count(
+        pub fn new(
             subservice: u8,
             apid: u16,
+            seq_count: u16,
+            msg_counter: u16,
             dest_id: u16,
-            time_stamp: [u8; 7],
+            timestamp: &[u8],
         ) -> Self {
             Self {
                 subservice,
                 apid,
-                seq_count: 0,
+                seq_count,
-                msg_counter: 0,
+                msg_counter,
                 dest_id,
-                time_stamp,
+                timestamp: timestamp.to_vec(),
             }
         }
+        pub fn new_zero_seq_count(
+            subservice: u8,
+            apid: u16,
+            dest_id: u16,
+            timestamp: &[u8],
+        ) -> Self {
+            Self::new(subservice, apid, 0, 0, dest_id, timestamp)
+        }
 
         pub fn new_from_tm(tm: &PusTmCreator) -> Self {
-            let mut time_stamp = [0; 7];
+            let mut timestamp = [0; 7];
-            time_stamp.clone_from_slice(&tm.timestamp()[0..7]);
+            timestamp.clone_from_slice(&tm.timestamp()[0..7]);
             Self {
                 subservice: PusPacket::subservice(tm),
                 apid: tm.apid(),
                 seq_count: tm.seq_count(),
                 msg_counter: tm.msg_counter(),
                 dest_id: tm.dest_id(),
-                time_stamp,
+                timestamp: timestamp.to_vec(),
             }
         }
     }

satrs/src/pus/verification.rs

@@ -1689,12 +1689,14 @@ pub mod test_util {
 
 #[cfg(test)]
 pub mod tests {
+    use crate::params::Params;
     use crate::pool::{SharedStaticMemoryPool, StaticMemoryPool, StaticPoolConfig};
     use crate::pus::test_util::{TEST_APID, TEST_COMPONENT_ID_0};
     use crate::pus::tests::CommonTmInfo;
     use crate::pus::verification::{
-        EcssTmSender, EcssTmtcError, FailParams, FailParamsWithStep, RequestId, TcStateNone,
+        handle_step_failure_with_generic_params, EcssTmSender, EcssTmtcError, FailParams,
-        VerificationReporter, VerificationReporterCfg, VerificationToken,
+        FailParamsWithStep, RequestId, TcStateNone, VerificationReporter, VerificationReporterCfg,
+        VerificationToken,
     };
     use crate::pus::{ChannelWithId, PusTmVariant};
     use crate::request::MessageMetadata;
@@ -1702,6 +1704,7 @@ pub mod tests {
     use crate::tmtc::{PacketSenderWithSharedPool, SharedPacketPool};
     use crate::ComponentId;
     use alloc::format;
+    use alloc::string::ToString;
     use spacepackets::ecss::tc::{PusTcCreator, PusTcReader, PusTcSecondaryHeader};
     use spacepackets::ecss::{
         EcssEnumU16, EcssEnumU32, EcssEnumU8, EcssEnumeration, PusError, PusPacket,
@@ -1716,8 +1719,9 @@ pub mod tests {
     use std::vec::Vec;
 
     use super::{
-        DummyVerificationHook, SeqCountProviderSimple, TcStateAccepted, TcStateStarted,
+        handle_completion_failure_with_generic_params, DummyVerificationHook, FailParamHelper,
-        VerificationHookProvider, VerificationReportingProvider, WasAtLeastAccepted,
+        SeqCountProviderSimple, TcStateAccepted, TcStateStarted, VerificationHookProvider,
+        VerificationReportingProvider, WasAtLeastAccepted,
     };
 
     fn is_send<T: Send>(_: &T) {}
@@ -1725,6 +1729,7 @@ pub mod tests {
     fn is_sync<T: Sync>(_: &T) {}
 
     const EMPTY_STAMP: [u8; 7] = [0; 7];
+    const DUMMY_STAMP: &[u8] = &[0, 1, 0, 1, 0, 1, 0];
 
     #[derive(Debug, Eq, PartialEq, Clone)]
     struct TmInfo {
@@ -1802,8 +1807,8 @@ pub mod tests {
         tc: Vec<u8>,
     }
 
-    fn base_reporter(id: ComponentId) -> VerificationReporter {
+    fn base_reporter(id: ComponentId, max_fail_data_len: usize) -> VerificationReporter {
-        let cfg = VerificationReporterCfg::new(TEST_APID, 1, 2, 8).unwrap();
+        let cfg = VerificationReporterCfg::new(TEST_APID, 1, 2, max_fail_data_len).unwrap();
         VerificationReporter::new(id, &cfg)
     }
 
@@ -1906,66 +1911,57 @@ pub mod tests {
                 .completion_failure(&self.sender, token, params)
         }
 
-        fn completion_success_check(&mut self, incrementing_couters: bool) {
+        fn check_acceptance_success(&self, timestamp: &[u8; 7]) {
-            assert_eq!(self.sender.service_queue.borrow().len(), 3);
-            let mut current_seq_count = 0;
             let cmp_info = TmInfo {
                 requestor: MessageMetadata::new(self.request_id.into(), self.id),
-                common: CommonTmInfo {
+                common: CommonTmInfo::new(1, TEST_APID, 0, 0, self.reporter.dest_id(), timestamp),
-                    subservice: 1,
-                    apid: TEST_APID,
-                    seq_count: current_seq_count,
-                    msg_counter: current_seq_count,
-                    dest_id: self.reporter.dest_id(),
-                    time_stamp: EMPTY_STAMP,
-                },
                 additional_data: None,
             };
-            let mut info = self.sender.service_queue.borrow_mut().pop_front().unwrap();
+            let mut service_queue = self.sender.service_queue.borrow_mut();
+            assert!(service_queue.len() >= 1);
+            let info = service_queue.pop_front().unwrap();
             assert_eq!(info, cmp_info);
+        }
 
-            if incrementing_couters {
+        fn check_start_success(&mut self, seq_count: u16, msg_counter: u16, timestamp: &[u8]) {
-                current_seq_count += 1;
+            let mut srv_queue = self.sender.service_queue.borrow_mut();
-            }
-
             let cmp_info = TmInfo {
                 requestor: MessageMetadata::new(self.request_id.into(), self.id),
-                common: CommonTmInfo {
+                common: CommonTmInfo::new(
-                    subservice: 3,
+                    3,
-                    apid: TEST_APID,
+                    TEST_APID,
-                    msg_counter: current_seq_count,
+                    seq_count,
-                    seq_count: current_seq_count,
+                    msg_counter,
-                    dest_id: self.reporter.dest_id(),
+                    self.reporter.dest_id(),
-                    time_stamp: [0, 1, 0, 1, 0, 1, 0],
+                    timestamp,
-                },
+                ),
                 additional_data: None,
             };
-            info = self.sender.service_queue.borrow_mut().pop_front().unwrap();
+            let info = srv_queue.pop_front().unwrap();
             assert_eq!(info, cmp_info);
+        }
 
-            if incrementing_couters {
+        fn check_completion_success(&mut self, seq_count: u16, msg_counter: u16) {
-                current_seq_count += 1;
-            }
             let cmp_info = TmInfo {
                 requestor: MessageMetadata::new(self.request_id.into(), self.id),
-                common: CommonTmInfo {
+                common: CommonTmInfo::new(
-                    subservice: 7,
+                    7,
-                    apid: TEST_APID,
+                    TEST_APID,
-                    msg_counter: current_seq_count,
+                    seq_count,
-                    seq_count: current_seq_count,
+                    msg_counter,
-                    dest_id: self.reporter.dest_id(),
+                    self.reporter.dest_id(),
-                    time_stamp: EMPTY_STAMP,
+                    &EMPTY_STAMP,
-                },
+                ),
                 additional_data: None,
             };
-            info = self.sender.service_queue.borrow_mut().pop_front().unwrap();
+            let info = self.sender.service_queue.borrow_mut().pop_front().unwrap();
             assert_eq!(info, cmp_info);
         }
     }
 
     impl VerificationReporterTestbench<DummyVerificationHook> {
-        fn new(id: ComponentId, tc: PusTcCreator) -> Self {
+        fn new(id: ComponentId, tc: PusTcCreator, max_fail_data_len: usize) -> Self {
-            let reporter = base_reporter(id);
+            let reporter = base_reporter(id, max_fail_data_len);
             Self {
                 id,
                 sender: TestSender::default(),
@@ -1975,36 +1971,10 @@ pub mod tests {
             }
         }
 
-        fn acceptance_check(&self, time_stamp: &[u8; 7]) {
+        fn check_acceptance_failure(&mut self, timestamp: &[u8; 7]) {
             let cmp_info = TmInfo {
                 requestor: MessageMetadata::new(self.request_id.into(), self.id),
-                common: CommonTmInfo {
+                common: CommonTmInfo::new(2, TEST_APID, 0, 0, self.reporter.dest_id(), timestamp),
-                    subservice: 1,
-                    apid: TEST_APID,
-                    seq_count: 0,
-                    msg_counter: 0,
-                    dest_id: self.reporter.dest_id(),
-                    time_stamp: *time_stamp,
-                },
-                additional_data: None,
-            };
-            let mut service_queue = self.sender.service_queue.borrow_mut();
-            assert_eq!(service_queue.len(), 1);
-            let info = service_queue.pop_front().unwrap();
-            assert_eq!(info, cmp_info);
-        }
-
-        fn acceptance_fail_check(&mut self, stamp_buf: [u8; 7]) {
-            let cmp_info = TmInfo {
-                requestor: MessageMetadata::new(self.request_id.into(), self.id),
-                common: CommonTmInfo {
-                    subservice: 2,
-                    seq_count: 0,
-                    apid: TEST_APID,
-                    msg_counter: 0,
-                    dest_id: self.reporter.dest_id(),
-                    time_stamp: stamp_buf,
-                },
                 additional_data: Some([0, 2].to_vec()),
             };
             let service_queue = self.sender.service_queue.get_mut();
@@ -2013,12 +1983,12 @@ pub mod tests {
             assert_eq!(info, cmp_info);
         }
 
-        fn start_fail_check(&mut self, fail_data_raw: [u8; 4]) {
+        fn check_start_failure(&mut self, fail_data_raw: [u8; 4]) {
             let mut srv_queue = self.sender.service_queue.borrow_mut();
             assert_eq!(srv_queue.len(), 2);
             let mut cmp_info = TmInfo {
                 requestor: MessageMetadata::new(self.request_id.into(), self.id),
-                common: CommonTmInfo::new_zero_seq_count(1, TEST_APID, 0, EMPTY_STAMP),
+                common: CommonTmInfo::new_zero_seq_count(1, TEST_APID, 0, &EMPTY_STAMP),
                 additional_data: None,
             };
             let mut info = srv_queue.pop_front().unwrap();
@@ -2026,148 +1996,67 @@ pub mod tests {
 
             cmp_info = TmInfo {
                 requestor: MessageMetadata::new(self.request_id.into(), self.id),
-                common: CommonTmInfo::new_zero_seq_count(4, TEST_APID, 0, EMPTY_STAMP),
+                common: CommonTmInfo::new_zero_seq_count(4, TEST_APID, 0, &EMPTY_STAMP),
                 additional_data: Some([&[22], fail_data_raw.as_slice()].concat().to_vec()),
             };
             info = srv_queue.pop_front().unwrap();
             assert_eq!(info, cmp_info);
         }
 
-        fn step_success_check(&mut self, time_stamp: &[u8; 7]) {
+        fn check_step_success(&mut self, step: u8, timestamp: &[u8; 7]) {
-            let mut cmp_info = TmInfo {
+            let cmp_info = TmInfo {
                 requestor: MessageMetadata::new(self.request_id.into(), self.id),
-                common: CommonTmInfo::new_zero_seq_count(1, TEST_APID, 0, *time_stamp),
+                common: CommonTmInfo::new_zero_seq_count(5, TEST_APID, 0, timestamp),
-                additional_data: None,
+                additional_data: Some([step].to_vec()),
             };
             let mut srv_queue = self.sender.service_queue.borrow_mut();
-            let mut info = srv_queue.pop_front().unwrap();
+            let info = srv_queue.pop_front().unwrap();
-            assert_eq!(info, cmp_info);
-            cmp_info = TmInfo {
-                requestor: MessageMetadata::new(self.request_id.into(), self.id),
-                common: CommonTmInfo::new_zero_seq_count(3, TEST_APID, 0, *time_stamp),
-                additional_data: None,
-            };
-            info = srv_queue.pop_front().unwrap();
-            assert_eq!(info, cmp_info);
-            cmp_info = TmInfo {
-                requestor: MessageMetadata::new(self.request_id.into(), self.id),
-                common: CommonTmInfo::new_zero_seq_count(5, TEST_APID, 0, *time_stamp),
-                additional_data: Some([0].to_vec()),
-            };
-            info = srv_queue.pop_front().unwrap();
-            assert_eq!(info, cmp_info);
-            cmp_info = TmInfo {
-                requestor: MessageMetadata::new(self.request_id.into(), self.id),
-                common: CommonTmInfo::new_zero_seq_count(5, TEST_APID, 0, *time_stamp),
-                additional_data: Some([1].to_vec()),
-            };
-            info = srv_queue.pop_front().unwrap();
             assert_eq!(info, cmp_info);
         }
 
-        fn check_step_failure(&mut self, fail_data_raw: [u8; 4]) {
+        fn check_step_failure(
-            assert_eq!(self.sender.service_queue.borrow().len(), 4);
+            &mut self,
-            let mut cmp_info = TmInfo {
+            step: &impl EcssEnumeration,
-                requestor: MessageMetadata::new(self.request_id.into(), self.id),
+            error_code: &impl EcssEnumeration,
-                common: CommonTmInfo::new_zero_seq_count(
+            fail_data: &[u8],
-                    1,
+        ) {
-                    TEST_APID,
+            let mut additional_data = Vec::new();
-                    self.reporter.dest_id(),
+            additional_data.extend(step.to_vec());
-                    EMPTY_STAMP,
+            additional_data.extend(error_code.to_vec());
-                ),
+            additional_data.extend(fail_data);
-                additional_data: None,
+            let cmp_info = TmInfo {
-            };
-            let mut info = self.sender.service_queue.borrow_mut().pop_front().unwrap();
-            assert_eq!(info, cmp_info);
-
-            cmp_info = TmInfo {
-                requestor: MessageMetadata::new(self.request_id.into(), self.id),
-                common: CommonTmInfo::new_zero_seq_count(
-                    3,
-                    TEST_APID,
-                    self.reporter.dest_id(),
-                    [0, 1, 0, 1, 0, 1, 0],
-                ),
-                additional_data: None,
-            };
-            info = self.sender.service_queue.borrow_mut().pop_front().unwrap();
-            assert_eq!(info, cmp_info);
-
-            cmp_info = TmInfo {
-                requestor: MessageMetadata::new(self.request_id.into(), self.id),
-                common: CommonTmInfo::new_zero_seq_count(
-                    5,
-                    TEST_APID,
-                    self.reporter.dest_id(),
-                    EMPTY_STAMP,
-                ),
-                additional_data: Some([0].to_vec()),
-            };
-            info = self.sender.service_queue.get_mut().pop_front().unwrap();
-            assert_eq!(info, cmp_info);
-
-            cmp_info = TmInfo {
                 requestor: MessageMetadata::new(self.request_id.into(), self.id),
                 common: CommonTmInfo::new_zero_seq_count(
                     6,
                     TEST_APID,
                     self.reporter.dest_id(),
-                    EMPTY_STAMP,
+                    &EMPTY_STAMP,
-                ),
-                additional_data: Some(
-                    [
-                        [1].as_slice(),
-                        &[0, 0, 0x10, 0x20],
-                        fail_data_raw.as_slice(),
-                    ]
-                    .concat()
-                    .to_vec(),
                 ),
+                additional_data: Some(additional_data),
             };
-            info = self.sender.service_queue.get_mut().pop_front().unwrap();
+            let info = self.sender.service_queue.get_mut().pop_front().unwrap();
             assert_eq!(info, cmp_info);
         }
 
-        fn completion_fail_check(&mut self) {
+        fn check_completion_failure(
-            assert_eq!(self.sender.service_queue.borrow().len(), 3);
+            &mut self,
-
+            error_code: &impl EcssEnumeration,
-            let mut cmp_info = TmInfo {
+            fail_data: &[u8],
-                requestor: MessageMetadata::new(self.request_id.into(), self.id),
+        ) {
-                common: CommonTmInfo::new_zero_seq_count(
+            let mut additional_data = Vec::new();
-                    1,
+            additional_data.extend(error_code.to_vec());
-                    TEST_APID,
+            additional_data.extend(fail_data);
-                    self.reporter.dest_id(),
+            let cmp_info = TmInfo {
-                    EMPTY_STAMP,
-                ),
-                additional_data: None,
-            };
-            let mut info = self.sender.service_queue.get_mut().pop_front().unwrap();
-            assert_eq!(info, cmp_info);
-
-            cmp_info = TmInfo {
-                requestor: MessageMetadata::new(self.request_id.into(), self.id),
-                common: CommonTmInfo::new_zero_seq_count(
-                    3,
-                    TEST_APID,
-                    self.reporter.dest_id(),
-                    [0, 1, 0, 1, 0, 1, 0],
-                ),
-                additional_data: None,
-            };
-            info = self.sender.service_queue.get_mut().pop_front().unwrap();
-            assert_eq!(info, cmp_info);
-
-            cmp_info = TmInfo {
                 requestor: MessageMetadata::new(self.request_id.into(), self.id),
                 common: CommonTmInfo::new_zero_seq_count(
                     8,
                     TEST_APID,
                     self.reporter.dest_id(),
-                    EMPTY_STAMP,
+                    &EMPTY_STAMP,
                 ),
-                additional_data: Some([0, 0, 0x10, 0x20].to_vec()),
+                additional_data: Some(additional_data),
             };
-            info = self.sender.service_queue.get_mut().pop_front().unwrap();
+            let info = self.sender.service_queue.get_mut().pop_front().unwrap();
             assert_eq!(info, cmp_info);
         }
     }
@@ -2190,7 +2079,7 @@ pub mod tests {
 
     #[test]
     fn test_state() {
-        let mut testbench = VerificationReporterTestbench::new(0, create_generic_ping());
+        let mut testbench = VerificationReporterTestbench::new(0, create_generic_ping(), 16);
         assert_eq!(testbench.reporter.apid(), TEST_APID);
         testbench.reporter.set_apid(TEST_APID + 1);
         assert_eq!(testbench.reporter.apid(), TEST_APID + 1);
@@ -2198,43 +2087,43 @@ pub mod tests {
 
     #[test]
     fn test_basic_acceptance_success() {
-        let mut testbench = VerificationReporterTestbench::new(0, create_generic_ping());
+        let mut testbench = VerificationReporterTestbench::new(0, create_generic_ping(), 16);
         let token = testbench.init();
         testbench
             .acceptance_success(token, &EMPTY_STAMP)
             .expect("sending acceptance success failed");
-        testbench.acceptance_check(&EMPTY_STAMP);
+        testbench.check_acceptance_success(&EMPTY_STAMP);
     }
 
     #[test]
     fn test_basic_acceptance_failure() {
-        let mut testbench = VerificationReporterTestbench::new(0, create_generic_ping());
+        let mut testbench = VerificationReporterTestbench::new(0, create_generic_ping(), 16);
         let init_token = testbench.init();
-        let stamp_buf = [1, 2, 3, 4, 5, 6, 7];
+        let timestamp = [1, 2, 3, 4, 5, 6, 7];
         let fail_code = EcssEnumU16::new(2);
-        let fail_params = FailParams::new_no_fail_data(stamp_buf.as_slice(), &fail_code);
+        let fail_params = FailParams::new_no_fail_data(timestamp.as_slice(), &fail_code);
         testbench
             .acceptance_failure(init_token, fail_params)
             .expect("sending acceptance failure failed");
-        testbench.acceptance_fail_check(stamp_buf);
+        testbench.check_acceptance_failure(&timestamp);
     }
 
     #[test]
     fn test_basic_acceptance_failure_with_helper() {
-        let mut testbench = VerificationReporterTestbench::new(0, create_generic_ping());
+        let mut testbench = VerificationReporterTestbench::new(0, create_generic_ping(), 16);
         let init_token = testbench.init();
-        let stamp_buf = [1, 2, 3, 4, 5, 6, 7];
+        let timestamp = [1, 2, 3, 4, 5, 6, 7];
         let fail_code = EcssEnumU16::new(2);
-        let fail_params = FailParams::new_no_fail_data(stamp_buf.as_slice(), &fail_code);
+        let fail_params = FailParams::new_no_fail_data(timestamp.as_slice(), &fail_code);
         testbench
             .acceptance_failure(init_token, fail_params)
             .expect("sending acceptance failure failed");
-        testbench.acceptance_fail_check(stamp_buf);
+        testbench.check_acceptance_failure(&timestamp);
     }
 
     #[test]
     fn test_acceptance_fail_data_too_large() {
-        let mut testbench = VerificationReporterTestbench::new(0, create_generic_ping());
+        let mut testbench = VerificationReporterTestbench::new(0, create_generic_ping(), 8);
         let init_token = testbench.init();
         let stamp_buf = [1, 2, 3, 4, 5, 6, 7];
         let fail_code = EcssEnumU16::new(2);
@@ -2266,7 +2155,7 @@ pub mod tests {
 
     #[test]
     fn test_basic_acceptance_failure_with_fail_data() {
-        let mut testbench = VerificationReporterTestbench::new(0, create_generic_ping());
+        let mut testbench = VerificationReporterTestbench::new(0, create_generic_ping(), 16);
         let fail_code = EcssEnumU8::new(10);
         let fail_data = EcssEnumU32::new(12);
         let mut fail_data_raw = [0; 4];
@@ -2278,7 +2167,7 @@ pub mod tests {
             .expect("sending acceptance failure failed");
         let cmp_info = TmInfo {
             requestor: MessageMetadata::new(testbench.request_id.into(), testbench.id),
-            common: CommonTmInfo::new_zero_seq_count(2, TEST_APID, 0, EMPTY_STAMP),
+            common: CommonTmInfo::new_zero_seq_count(2, TEST_APID, 0, &EMPTY_STAMP),
             additional_data: Some([10, 0, 0, 0, 12].to_vec()),
         };
         let mut service_queue = testbench.sender.service_queue.borrow_mut();
@@ -2289,7 +2178,7 @@ pub mod tests {
 
     #[test]
     fn test_start_failure() {
-        let mut testbench = VerificationReporterTestbench::new(0, create_generic_ping());
+        let mut testbench = VerificationReporterTestbench::new(0, create_generic_ping(), 16);
         let init_token = testbench.init();
         let fail_code = EcssEnumU8::new(22);
         let fail_data: i32 = -12;
@@ -2303,12 +2192,12 @@ pub mod tests {
         testbench
             .start_failure(accepted_token, fail_params)
             .expect("Start failure failure");
-        testbench.start_fail_check(fail_data_raw);
+        testbench.check_start_failure(fail_data_raw);
     }
 
     #[test]
     fn test_start_failure_with_helper() {
-        let mut testbench = VerificationReporterTestbench::new(0, create_generic_ping());
+        let mut testbench = VerificationReporterTestbench::new(0, create_generic_ping(), 16);
         let token = testbench.init();
         let fail_code = EcssEnumU8::new(22);
         let fail_data: i32 = -12;
@@ -2322,12 +2211,12 @@ pub mod tests {
         testbench
             .start_failure(accepted_token, fail_params)
             .expect("start failure failed");
-        testbench.start_fail_check(fail_data_raw);
+        testbench.check_start_failure(fail_data_raw);
     }
 
     #[test]
     fn test_steps_success() {
-        let mut testbench = VerificationReporterTestbench::new(0, create_generic_ping());
+        let mut testbench = VerificationReporterTestbench::new(0, create_generic_ping(), 16);
         let token = testbench.init();
         let accepted_token = testbench
             .acceptance_success(token, &EMPTY_STAMP)
@@ -2342,12 +2231,15 @@ pub mod tests {
             .step_success(&started_token, &EMPTY_STAMP, EcssEnumU8::new(1))
             .expect("step 1 failed");
         assert_eq!(testbench.sender.service_queue.borrow().len(), 4);
-        testbench.step_success_check(&EMPTY_STAMP);
+        testbench.check_acceptance_success(&EMPTY_STAMP);
+        testbench.check_start_success(0, 0, &EMPTY_STAMP);
+        testbench.check_step_success(0, &EMPTY_STAMP);
+        testbench.check_step_success(1, &EMPTY_STAMP);
     }
 
     #[test]
     fn test_step_failure() {
-        let mut testbench = VerificationReporterTestbench::new(0, create_generic_ping());
+        let mut testbench = VerificationReporterTestbench::new(0, create_generic_ping(), 16);
         let token = testbench.init();
         let fail_code = EcssEnumU32::new(0x1020);
         let fail_data: f32 = -22.3232;
@@ -2365,7 +2257,7 @@ pub mod tests {
             .acceptance_success(token, &EMPTY_STAMP)
             .expect("Sending acceptance success failed");
         let started_token = testbench
-            .start_success(accepted_token, &[0, 1, 0, 1, 0, 1, 0])
+            .start_success(accepted_token, DUMMY_STAMP)
             .expect("Sending start success failed");
         testbench
             .step_success(&started_token, &EMPTY_STAMP, EcssEnumU8::new(0))
@@ -2373,12 +2265,15 @@ pub mod tests {
         testbench
             .step_failure(started_token, fail_params)
             .expect("Step failure failed");
-        testbench.check_step_failure(fail_data_raw);
+        testbench.check_acceptance_success(&EMPTY_STAMP);
+        testbench.check_start_success(0, 0, DUMMY_STAMP);
+        testbench.check_step_success(0, &EMPTY_STAMP);
+        testbench.check_step_failure(&fail_step, &fail_code, &fail_data_raw);
     }
 
     #[test]
     fn test_completion_failure() {
-        let mut testbench = VerificationReporterTestbench::new(0, create_generic_ping());
+        let mut testbench = VerificationReporterTestbench::new(0, create_generic_ping(), 16);
         let token = testbench.init();
         let fail_code = EcssEnumU32::new(0x1020);
         let fail_params = FailParams::new_no_fail_data(&EMPTY_STAMP, &fail_code);
@@ -2387,29 +2282,34 @@ pub mod tests {
             .acceptance_success(token, &EMPTY_STAMP)
             .expect("Sending acceptance success failed");
         let started_token = testbench
-            .start_success(accepted_token, &[0, 1, 0, 1, 0, 1, 0])
+            .start_success(accepted_token, DUMMY_STAMP)
             .expect("Sending start success failed");
         testbench
             .completion_failure(started_token, fail_params)
             .expect("Completion failure");
-        testbench.completion_fail_check();
+        testbench.check_acceptance_success(&EMPTY_STAMP);
+        testbench.check_start_success(0, 0, DUMMY_STAMP);
+
+        testbench.check_completion_failure(&fail_code, &[]);
     }
 
     #[test]
     fn test_complete_success_sequence() {
         let mut testbench =
-            VerificationReporterTestbench::new(TEST_COMPONENT_ID_0.id(), create_generic_ping());
+            VerificationReporterTestbench::new(TEST_COMPONENT_ID_0.id(), create_generic_ping(), 16);
         let token = testbench.init();
         let accepted_token = testbench
             .acceptance_success(token, &EMPTY_STAMP)
             .expect("Sending acceptance success failed");
         let started_token = testbench
-            .start_success(accepted_token, &[0, 1, 0, 1, 0, 1, 0])
+            .start_success(accepted_token, DUMMY_STAMP)
             .expect("Sending start success failed");
         testbench
             .completion_success(started_token, &EMPTY_STAMP)
             .expect("Sending completion success failed");
-        testbench.completion_success_check(false);
+        testbench.check_acceptance_success(&EMPTY_STAMP);
+        testbench.check_start_success(0, 0, DUMMY_STAMP);
+        testbench.check_completion_success(0, 0);
     }
 
     #[test]
@@ -2429,16 +2329,83 @@ pub mod tests {
         testbench
             .completion_success(started_token, &EMPTY_STAMP)
             .expect("Sending completion success failed");
-        testbench.completion_success_check(true);
+        testbench.check_acceptance_success(&EMPTY_STAMP);
+        testbench.check_start_success(1, 1, DUMMY_STAMP);
+        testbench.check_completion_success(2, 2);
     }
 
     #[test]
-    fn test_completion_failure_helper() {
+    fn test_completion_failure_helper_string_param() {
-        // TODO: Add tests for this.
+        let mut testbench = VerificationReporterTestbench::new(0, create_generic_ping(), 32);
+        let token = testbench.init();
+        let accepted_token = testbench
+            .acceptance_success(token, &EMPTY_STAMP)
+            .expect("Sending acceptance success failed");
+        let mut small_data_buf: [u8; 16] = [0; 16];
+        let fail_code = EcssEnumU8::new(1);
+        let fail_data = "error 404 oh no".to_string();
+        let fail_params = Params::String(fail_data.clone());
+        let result = handle_completion_failure_with_generic_params(
+            &testbench.sender,
+            accepted_token,
+            &testbench.reporter,
+            FailParamHelper {
+                timestamp: &EMPTY_STAMP,
+                error_code: &fail_code,
+                small_data_buf: &mut small_data_buf,
+                params: Some(&fail_params),
+            },
+        );
+        assert!(result.unwrap());
+        testbench.check_acceptance_success(&EMPTY_STAMP);
+        testbench.check_completion_failure(&fail_code, fail_data.as_bytes());
     }
 
     #[test]
-    fn test_step_failure_helper() {
+    fn test_step_failure_helper_string_param() {
-        // TODO: Add tests for this.
+        let mut testbench = VerificationReporterTestbench::new(0, create_generic_ping(), 32);
+        let token = testbench.init();
+        let accepted_token = testbench
+            .acceptance_success(token, &EMPTY_STAMP)
+            .expect("Sending acceptance success failed");
+        let started_token = testbench
+            .start_success(accepted_token, &EMPTY_STAMP)
+            .expect("Sending start success failed");
+        let mut small_data_buf: [u8; 16] = [0; 16];
+        let step = EcssEnumU8::new(2);
+        let fail_code = EcssEnumU8::new(1);
+        let fail_data = "AAAAAAAAAAAHHHHHH".to_string();
+        let fail_params = Params::String(fail_data.clone());
+        let result = handle_step_failure_with_generic_params(
+            &testbench.sender,
+            started_token,
+            &testbench.reporter,
+            FailParamHelper {
+                timestamp: &EMPTY_STAMP,
+                error_code: &fail_code,
+                small_data_buf: &mut small_data_buf,
+                params: Some(&fail_params),
+            },
+            &step,
+        );
+        assert!(result.unwrap());
+        testbench.check_acceptance_success(&EMPTY_STAMP);
+        testbench.check_start_success(0, 0, &EMPTY_STAMP);
+        testbench.check_step_failure(&step, &fail_code, fail_data.as_bytes());
+    }
+
+    #[test]
+    fn test_completion_failure_helper_vec_param() {
+        // TODO: Test this.
+    }
+
+    #[test]
+    fn test_completion_failure_helper_raw_param() {
+        // TODO: Test this.
+    }
+
+    #[test]
+    fn test_completion_failure_helper_store_param_ignored() {
+        // TODO: Test this.
     }
 }