that gets the job done

satrs/src/encoding/ccsds.rs

@@ -2,60 +2,71 @@
 use alloc::vec::Vec;
 #[cfg(feature = "alloc")]
 use hashbrown::HashSet;
+#[cfg(feature = "std")]
+use std::collections::HashSet as StdHashSet;
+
 use spacepackets::PacketId;
 
 use crate::tmtc::ReceivesTcCore;
 
-pub trait PacketIdLookup {
+pub trait PacketIdValidator {
     fn validate(&self, packet_id: u16) -> bool;
 }
 
 #[cfg(feature = "alloc")]
-impl PacketIdLookup for Vec<u16> {
+impl PacketIdValidator for Vec<u16> {
     fn validate(&self, packet_id: u16) -> bool {
         self.contains(&packet_id)
     }
 }
 
 #[cfg(feature = "alloc")]
-impl PacketIdLookup for HashSet<u16> {
+impl PacketIdValidator for HashSet<u16> {
     fn validate(&self, packet_id: u16) -> bool {
         self.contains(&packet_id)
     }
 }
 
-impl PacketIdLookup for [u16] {
+impl PacketIdValidator for [u16] {
     fn validate(&self, packet_id: u16) -> bool {
         self.binary_search(&packet_id).is_ok()
     }
 }
 
-impl PacketIdLookup for &[u16] {
+impl PacketIdValidator for &[u16] {
     fn validate(&self, packet_id: u16) -> bool {
         self.binary_search(&packet_id).is_ok()
     }
 }
 
 #[cfg(feature = "alloc")]
-impl PacketIdLookup for Vec<PacketId> {
-    fn validate(&self, packet_id: u16) -> bool {
-        self.contains(&PacketId::from(packet_id))
-    }
-}
-#[cfg(feature = "alloc")]
-impl PacketIdLookup for HashSet<PacketId> {
+impl PacketIdValidator for Vec<PacketId> {
     fn validate(&self, packet_id: u16) -> bool {
         self.contains(&PacketId::from(packet_id))
     }
 }
 
-impl PacketIdLookup for [PacketId] {
+#[cfg(feature = "alloc")]
+impl PacketIdValidator for HashSet<PacketId> {
+    fn validate(&self, packet_id: u16) -> bool {
+        self.contains(&PacketId::from(packet_id))
+    }
+}
+
+#[cfg(feature = "std")]
+impl PacketIdValidator for StdHashSet<PacketId> {
+    fn validate(&self, packet_id: u16) -> bool {
+        self.contains(&PacketId::from(packet_id))
+    }
+}
+
+impl PacketIdValidator for [PacketId] {
     fn validate(&self, packet_id: u16) -> bool {
         self.binary_search(&PacketId::from(packet_id)).is_ok()
     }
 }
 
-impl PacketIdLookup for &[PacketId] {
+impl PacketIdValidator for &[PacketId] {
     fn validate(&self, packet_id: u16) -> bool {
         self.binary_search(&PacketId::from(packet_id)).is_ok()
     }
@@ -75,7 +86,7 @@ impl PacketIdLookup for &[PacketId] {
 /// error will be returned.
 pub fn parse_buffer_for_ccsds_space_packets<E>(
     buf: &mut [u8],
-    packet_id_lookup: &(impl PacketIdLookup + ?Sized),
+    packet_id_validator: &(impl PacketIdValidator + ?Sized),
     tc_receiver: &mut (impl ReceivesTcCore<Error = E> + ?Sized),
     next_write_idx: &mut usize,
 ) -> Result<u32, E> {
@@ -88,7 +99,7 @@ pub fn parse_buffer_for_ccsds_space_packets<E>(
             break;
         }
         let packet_id = u16::from_be_bytes(buf[current_idx..current_idx + 2].try_into().unwrap());
-        if packet_id_lookup.validate(packet_id) {
+        if packet_id_validator.validate(packet_id) {
             let length_field =
                 u16::from_be_bytes(buf[current_idx + 4..current_idx + 6].try_into().unwrap());
             let packet_size = length_field + 7;

satrs/src/hal/std/tcp_spacepackets_server.rs

@@ -4,10 +4,8 @@ use std::{
     net::{SocketAddr, TcpListener, TcpStream},
 };
 
-use alloc::boxed::Box;
-
 use crate::{
-    encoding::{ccsds::PacketIdLookup, parse_buffer_for_ccsds_space_packets},
+    encoding::{ccsds::PacketIdValidator, parse_buffer_for_ccsds_space_packets},
     tmtc::{ReceivesTc, TmPacketSource},
 };
 
@@ -16,17 +14,19 @@ use super::tcp_server::{
 };
 
 /// Concrete [TcpTcParser] implementation for the [TcpSpacepacketsServer].
-pub struct SpacepacketsTcParser {
-    packet_id_lookup: Box<dyn PacketIdLookup + Send>,
+pub struct SpacepacketsTcParser<PacketIdChecker: PacketIdValidator> {
+    packet_id_lookup: PacketIdChecker,
 }
 
-impl SpacepacketsTcParser {
-    pub fn new(packet_id_lookup: Box<dyn PacketIdLookup + Send>) -> Self {
+impl<PacketIdChecker: PacketIdValidator> SpacepacketsTcParser<PacketIdChecker> {
+    pub fn new(packet_id_lookup: PacketIdChecker) -> Self {
         Self { packet_id_lookup }
     }
 }
 
-impl<TmError, TcError: 'static> TcpTcParser<TmError, TcError> for SpacepacketsTcParser {
+impl<TmError, TcError: 'static, PacketIdChecker: PacketIdValidator> TcpTcParser<TmError, TcError>
+    for SpacepacketsTcParser<PacketIdChecker>
+{
     fn handle_tc_parsing(
         &mut self,
         tc_buffer: &mut [u8],
@@ -38,7 +38,7 @@ impl<TmError, TcError: 'static> TcpTcParser<TmError, TcError> for SpacepacketsTc
         // Reader vec full, need to parse for packets.
         conn_result.num_received_tcs += parse_buffer_for_ccsds_space_packets(
             &mut tc_buffer[..current_write_idx],
-            self.packet_id_lookup.as_ref(),
+            &self.packet_id_lookup,
             tc_receiver.upcast_mut(),
             next_write_idx,
         )
@@ -95,6 +95,7 @@ pub struct TcpSpacepacketsServer<
     TcError: 'static,
     TmSource: TmPacketSource<Error = TmError>,
     TcReceiver: ReceivesTc<Error = TcError>,
+    PacketIdChecker: PacketIdValidator,
 > {
     generic_server: TcpTmtcGenericServer<
         TmError,
@@ -102,7 +103,7 @@ pub struct TcpSpacepacketsServer<
         TmSource,
         TcReceiver,
         SpacepacketsTmSender,
-        SpacepacketsTcParser,
+        SpacepacketsTcParser<PacketIdChecker>,
     >,
 }
 
@@ -111,7 +112,8 @@ impl<
         TcError: 'static,
         TmSource: TmPacketSource<Error = TmError>,
         TcReceiver: ReceivesTc<Error = TcError>,
-    > TcpSpacepacketsServer<TmError, TcError, TmSource, TcReceiver>
+        PacketIdChecker: PacketIdValidator,
+    > TcpSpacepacketsServer<TmError, TcError, TmSource, TcReceiver, PacketIdChecker>
 {
     ///
     /// ## Parameter
@@ -127,12 +129,12 @@ impl<
         cfg: ServerConfig,
         tm_source: TmSource,
         tc_receiver: TcReceiver,
-        packet_id_lookup: Box<dyn PacketIdLookup + Send>,
+        packet_id_checker: PacketIdChecker,
     ) -> Result<Self, std::io::Error> {
         Ok(Self {
             generic_server: TcpTmtcGenericServer::new(
                 cfg,
-                SpacepacketsTcParser::new(packet_id_lookup),
+                SpacepacketsTcParser::new(packet_id_checker),
                 SpacepacketsTmSender::default(),
                 tm_source,
                 tc_receiver,
@@ -170,7 +172,7 @@ mod tests {
         thread,
     };
 
-    use alloc::{boxed::Box, sync::Arc};
+    use alloc::sync::Arc;
     use hashbrown::HashSet;
     use spacepackets::{
         ecss::{tc::PusTcCreator, WritablePusPacket},
@@ -194,12 +196,12 @@ mod tests {
         tc_receiver: SyncTcCacher,
         tm_source: SyncTmSource,
         packet_id_lookup: HashSet<PacketId>,
-    ) -> TcpSpacepacketsServer<(), (), SyncTmSource, SyncTcCacher> {
+    ) -> TcpSpacepacketsServer<(), (), SyncTmSource, SyncTcCacher, HashSet<PacketId>> {
         TcpSpacepacketsServer::new(
             ServerConfig::new(*addr, Duration::from_millis(2), 1024, 1024),
             tm_source,
             tc_receiver,
-            Box::new(packet_id_lookup),
+            packet_id_lookup,
         )
         .expect("TCP server generation failed")
     }

satrs/src/pus/event.rs

@@ -6,8 +6,10 @@ use spacepackets::ByteConversionError;
 use spacepackets::{SpHeader, MAX_APID};
 
 use crate::pus::EcssTmSenderCore;
+
 #[cfg(feature = "alloc")]
-pub use alloc_mod::EventReporter;
+pub use alloc_mod::*;
+
 pub use spacepackets::ecss::event::*;
 
 pub struct EventReportCreator {
@@ -16,102 +18,98 @@ pub struct EventReportCreator {
 }
 
 impl EventReportCreator {
-    pub fn new(apid: u16) -> Option<Self> {
+    pub fn new(apid: u16, dest_id: u16) -> Option<Self> {
         if apid > MAX_APID {
             return None;
         }
-        Some(Self {
-            // msg_count: 0,
-            dest_id: 0,
-            apid,
-        })
+        Some(Self { dest_id, apid })
     }
 
     pub fn event_info<'time, 'src_data>(
         &self,
-        src_data_buf: &'src_data mut [u8],
         time_stamp: &'time [u8],
         event_id: impl EcssEnumeration,
-        aux_data: Option<&'src_data [u8]>,
+        params: Option<&'src_data [u8]>,
+        src_data_buf: &'src_data mut [u8],
     ) -> Result<PusTmCreator<'time, 'src_data>, ByteConversionError> {
         self.generate_and_send_generic_tm(
-            src_data_buf,
             Subservice::TmInfoReport,
             time_stamp,
             event_id,
-            aux_data,
+            params,
+            src_data_buf,
         )
     }
 
     pub fn event_low_severity<'time, 'src_data>(
         &self,
-        src_data_buf: &'src_data mut [u8],
         time_stamp: &'time [u8],
         event_id: impl EcssEnumeration,
-        aux_data: Option<&'src_data [u8]>,
+        params: Option<&'src_data [u8]>,
+        src_data_buf: &'src_data mut [u8],
     ) -> Result<PusTmCreator<'time, 'src_data>, ByteConversionError> {
         self.generate_and_send_generic_tm(
-            src_data_buf,
             Subservice::TmLowSeverityReport,
             time_stamp,
             event_id,
-            aux_data,
+            params,
+            src_data_buf,
         )
     }
 
     pub fn event_medium_severity<'time, 'src_data>(
         &self,
-        buf: &'src_data mut [u8],
         time_stamp: &'time [u8],
         event_id: impl EcssEnumeration,
-        aux_data: Option<&'src_data [u8]>,
+        params: Option<&'src_data [u8]>,
+        buf: &'src_data mut [u8],
     ) -> Result<PusTmCreator<'time, 'src_data>, ByteConversionError> {
         self.generate_and_send_generic_tm(
-            buf,
             Subservice::TmMediumSeverityReport,
             time_stamp,
             event_id,
-            aux_data,
+            params,
+            buf,
         )
     }
 
     pub fn event_high_severity<'time, 'src_data>(
         &self,
-        src_data_buf: &'src_data mut [u8],
         time_stamp: &'time [u8],
         event_id: impl EcssEnumeration,
-        aux_data: Option<&'src_data [u8]>,
+        params: Option<&'src_data [u8]>,
+        src_data_buf: &'src_data mut [u8],
     ) -> Result<PusTmCreator<'time, 'src_data>, ByteConversionError> {
         self.generate_and_send_generic_tm(
-            src_data_buf,
             Subservice::TmHighSeverityReport,
             time_stamp,
             event_id,
-            aux_data,
+            params,
+            src_data_buf,
         )
     }
 
     fn generate_and_send_generic_tm<'time, 'src_data>(
         &self,
-        src_data_buf: &'src_data mut [u8],
         subservice: Subservice,
         time_stamp: &'time [u8],
         event_id: impl EcssEnumeration,
-        aux_data: Option<&'src_data [u8]>,
+        params: Option<&'src_data [u8]>,
+        src_data_buf: &'src_data mut [u8],
     ) -> Result<PusTmCreator<'time, 'src_data>, ByteConversionError> {
-        self.generate_generic_event_tm(src_data_buf, subservice, time_stamp, event_id, aux_data)
+        self.generate_generic_event_tm(subservice, time_stamp, event_id, params, src_data_buf)
     }
 
     fn generate_generic_event_tm<'time, 'src_data>(
         &self,
-        src_data_buf: &'src_data mut [u8],
         subservice: Subservice,
         time_stamp: &'time [u8],
         event_id: impl EcssEnumeration,
-        aux_data: Option<&'src_data [u8]>,
+        params: Option<&'src_data [u8]>,
+        src_data_buf: &'src_data mut [u8],
     ) -> Result<PusTmCreator<'time, 'src_data>, ByteConversionError> {
         let mut src_data_len = event_id.size();
-        if let Some(aux_data) = aux_data {
+        if let Some(aux_data) = params {
             src_data_len += aux_data.len();
         }
         source_buffer_large_enough(src_data_buf.len(), src_data_len)?;
@@ -121,7 +119,7 @@ impl EventReportCreator {
         let mut current_idx = 0;
         event_id.write_to_be_bytes(&mut src_data_buf[0..event_id.size()])?;
         current_idx += event_id.size();
-        if let Some(aux_data) = aux_data {
+        if let Some(aux_data) = params {
             src_data_buf[current_idx..current_idx + aux_data.len()].copy_from_slice(aux_data);
             current_idx += aux_data.len();
         }
@@ -142,25 +140,56 @@ mod alloc_mod {
     use alloc::vec::Vec;
     use core::cell::RefCell;
 
-    pub struct EventReporter {
+    pub trait EventTmHookProvider {
+        fn modify_tm(&self, tm: &mut PusTmCreator);
+    }
+
+    #[derive(Default)]
+    pub struct DummyEventHook {}
+
+    impl EventTmHookProvider for DummyEventHook {
+        fn modify_tm(&self, _tm: &mut PusTmCreator) {}
+    }
+
+    pub struct EventReporter<EventTmHook: EventTmHookProvider = DummyEventHook> {
         id: ComponentId,
         // Use interior mutability pattern here. This is just an intermediate buffer to the PUS event packet
         // generation.
         source_data_buf: RefCell<Vec<u8>>,
         pub report_creator: EventReportCreator,
+        pub tm_hook: EventTmHook,
     }
 
-    impl EventReporter {
+    impl EventReporter<DummyEventHook> {
         pub fn new(
             id: ComponentId,
-            apid: u16,
+            default_apid: u16,
+            default_dest_id: u16,
             max_event_id_and_aux_data_size: usize,
         ) -> Option<Self> {
-            let reporter = EventReportCreator::new(apid)?;
+            let reporter = EventReportCreator::new(default_apid, default_dest_id)?;
             Some(Self {
                 id,
                 source_data_buf: RefCell::new(vec![0; max_event_id_and_aux_data_size]),
                 report_creator: reporter,
+                tm_hook: DummyEventHook::default(),
+            })
+        }
+    }
+    impl<EventTmHook: EventTmHookProvider> EventReporter<EventTmHook> {
+        pub fn new_with_hook(
+            id: ComponentId,
+            default_apid: u16,
+            default_dest_id: u16,
+            max_event_id_and_aux_data_size: usize,
+            tm_hook: EventTmHook,
+        ) -> Option<Self> {
+            let reporter = EventReportCreator::new(default_apid, default_dest_id)?;
+            Some(Self {
+                id,
+                source_data_buf: RefCell::new(vec![0; max_event_id_and_aux_data_size]),
+                report_creator: reporter,
+                tm_hook,
             })
         }
 
@@ -169,13 +198,14 @@ mod alloc_mod {
             sender: &(impl EcssTmSenderCore + ?Sized),
             time_stamp: &[u8],
             event_id: impl EcssEnumeration,
-            aux_data: Option<&[u8]>,
+            params: Option<&[u8]>,
         ) -> Result<(), EcssTmtcError> {
             let mut mut_buf = self.source_data_buf.borrow_mut();
-            let tm_creator = self
+            let mut tm_creator = self
                 .report_creator
-                .event_info(mut_buf.as_mut_slice(), time_stamp, event_id, aux_data)
+                .event_info(time_stamp, event_id, params, mut_buf.as_mut_slice())
                 .map_err(PusError::ByteConversion)?;
+            self.tm_hook.modify_tm(&mut tm_creator);
             sender.send_tm(self.id, tm_creator.into())?;
             Ok(())
         }
@@ -185,13 +215,14 @@ mod alloc_mod {
             sender: &(impl EcssTmSenderCore + ?Sized),
             time_stamp: &[u8],
             event_id: impl EcssEnumeration,
-            aux_data: Option<&[u8]>,
+            params: Option<&[u8]>,
         ) -> Result<(), EcssTmtcError> {
             let mut mut_buf = self.source_data_buf.borrow_mut();
-            let tm_creator = self
+            let mut tm_creator = self
                 .report_creator
-                .event_low_severity(mut_buf.as_mut_slice(), time_stamp, event_id, aux_data)
+                .event_low_severity(time_stamp, event_id, params, mut_buf.as_mut_slice())
                 .map_err(PusError::ByteConversion)?;
+            self.tm_hook.modify_tm(&mut tm_creator);
             sender.send_tm(self.id, tm_creator.into())?;
             Ok(())
         }
@@ -201,13 +232,14 @@ mod alloc_mod {
             sender: &(impl EcssTmSenderCore + ?Sized),
             time_stamp: &[u8],
             event_id: impl EcssEnumeration,
-            aux_data: Option<&[u8]>,
+            params: Option<&[u8]>,
         ) -> Result<(), EcssTmtcError> {
             let mut mut_buf = self.source_data_buf.borrow_mut();
-            let tm_creator = self
+            let mut tm_creator = self
                 .report_creator
-                .event_medium_severity(mut_buf.as_mut_slice(), time_stamp, event_id, aux_data)
+                .event_medium_severity(time_stamp, event_id, params, mut_buf.as_mut_slice())
                 .map_err(PusError::ByteConversion)?;
+            self.tm_hook.modify_tm(&mut tm_creator);
             sender.send_tm(self.id, tm_creator.into())?;
             Ok(())
         }
@@ -217,13 +249,14 @@ mod alloc_mod {
             sender: &(impl EcssTmSenderCore + ?Sized),
             time_stamp: &[u8],
             event_id: impl EcssEnumeration,
-            aux_data: Option<&[u8]>,
+            params: Option<&[u8]>,
         ) -> Result<(), EcssTmtcError> {
             let mut mut_buf = self.source_data_buf.borrow_mut();
-            let tm_creator = self
+            let mut tm_creator = self
                 .report_creator
-                .event_high_severity(mut_buf.as_mut_slice(), time_stamp, event_id, aux_data)
+                .event_high_severity(time_stamp, event_id, params, mut_buf.as_mut_slice())
                 .map_err(PusError::ByteConversion)?;
+            self.tm_hook.modify_tm(&mut tm_creator);
             sender.send_tm(self.id, tm_creator.into())?;
             Ok(())
         }
@@ -346,6 +379,7 @@ mod tests {
         let reporter = EventReporter::new(
             TEST_COMPONENT_ID_0.id(),
             EXAMPLE_APID,
+            0,
             max_event_aux_data_buf,
         );
         assert!(reporter.is_some());
@@ -440,7 +474,7 @@ mod tests {
     fn insufficient_buffer() {
         let mut sender = TestSender::default();
         for i in 0..3 {
-            let reporter = EventReporter::new(0, EXAMPLE_APID, i);
+            let reporter = EventReporter::new(0, EXAMPLE_APID, 0, i);
             assert!(reporter.is_some());
             let mut reporter = reporter.unwrap();
             check_buf_too_small(&mut reporter, &mut sender, i);

satrs/src/tmtc/ccsds_distrib.rs

@@ -81,7 +81,10 @@
 //! let mutable_handler_ref = ccsds_distributor.packet_handler_mut();
 //! mutable_handler_ref.mutable_foo();
 //! ```
-use crate::tmtc::{ReceivesCcsdsTc, ReceivesTcCore};
+use crate::{
+    encoding::ccsds::PacketIdValidator,
+    tmtc::{ReceivesCcsdsTc, ReceivesTcCore},
+};
 use core::fmt::{Display, Formatter};
 use spacepackets::{ByteConversionError, CcsdsPacket, SpHeader};
 #[cfg(feature = "std")]
@@ -93,14 +96,16 @@ use std::error::Error;
 /// instance of this handler to the [CcsdsDistributor]. The distributor will use the trait
 /// interface to dispatch received packets to the user based on the Application Process Identifier
 /// (APID) field of the CCSDS packet.
-pub trait CcsdsPacketHandler {
+pub trait CcsdsPacketHandler: PacketIdValidator {
     type Error;
 
-    // TODO: Rework this to return a boolean based on u16 input..
-    fn valid_apids(&self) -> &'static [u16];
-    fn handle_known_apid(&mut self, sp_header: &SpHeader, tc_raw: &[u8])
-        -> Result<(), Self::Error>;
-    fn handle_unknown_apid(
+    fn handle_packet_with_valid_apid(
+        &mut self,
+        sp_header: &SpHeader,
+        tc_raw: &[u8],
+    ) -> Result<(), Self::Error>;
+
+    fn handle_packet_with_unknown_apid(
         &mut self,
         sp_header: &SpHeader,
         tc_raw: &[u8],
@@ -184,18 +189,16 @@ impl<PacketHandler: CcsdsPacketHandler<Error = E>, E: 'static> CcsdsDistributor<
     }
 
     fn dispatch_ccsds(&mut self, sp_header: &SpHeader, tc_raw: &[u8]) -> Result<(), CcsdsError<E>> {
-        let apid = sp_header.apid();
-        let valid_apids = self.packet_handler.valid_apids();
-        for &valid_apid in valid_apids {
-            if valid_apid == apid {
-                return self
-                    .packet_handler
-                    .handle_known_apid(sp_header, tc_raw)
-                    .map_err(|e| CcsdsError::CustomError(e));
-            }
+        //let valid_apids = self.packet_handler.valid_apids();
+        let valid_apid = self.packet_handler().validate(sp_header.packet_id().raw());
+        if valid_apid {
+            return self
+                .packet_handler
+                .handle_packet_with_valid_apid(sp_header, tc_raw)
+                .map_err(|e| CcsdsError::CustomError(e));
         }
         self.packet_handler
-            .handle_unknown_apid(sp_header, tc_raw)
+            .handle_packet_with_unknown_apid(sp_header, tc_raw)
             .map_err(|e| CcsdsError::CustomError(e))
     }
 }
@@ -242,13 +245,16 @@ pub(crate) mod tests {
         pub unknown_packet_queue: VecDeque<(u16, Vec<u8>)>,
     }
 
+    impl PacketIdValidator for BasicApidHandlerSharedQueue {
+        fn validate(&self, packet_id: u16) -> bool {
+            &[0x000, 0x002].contains(&packet_id)
+        }
+    }
+
     impl CcsdsPacketHandler for BasicApidHandlerSharedQueue {
         type Error = ();
-        fn valid_apids(&self) -> &'static [u16] {
-            &[0x000, 0x002]
-        }
 
-        fn handle_known_apid(
+        fn handle_packet_with_valid_apid(
             &mut self,
             sp_header: &SpHeader,
             tc_raw: &[u8],
@@ -262,7 +268,7 @@ pub(crate) mod tests {
             Ok(())
         }
 
-        fn handle_unknown_apid(
+        fn handle_packet_with_unknown_apid(
             &mut self,
             sp_header: &SpHeader,
             tc_raw: &[u8],
@@ -277,14 +283,16 @@ pub(crate) mod tests {
         }
     }
 
+    impl PacketIdValidator for BasicApidHandlerOwnedQueue {
+        fn validate(&self, packet_id: u16) -> bool {
+            &[0x000, 0x002].contains(&packet_id)
+        }
+    }
+
     impl CcsdsPacketHandler for BasicApidHandlerOwnedQueue {
         type Error = ();
 
-        fn valid_apids(&self) -> &'static [u16] {
-            &[0x000, 0x002]
-        }
-
-        fn handle_known_apid(
+        fn handle_packet_with_valid_apid(
             &mut self,
             sp_header: &SpHeader,
             tc_raw: &[u8],
@@ -295,7 +303,7 @@ pub(crate) mod tests {
             Ok(())
         }
 
-        fn handle_unknown_apid(
+        fn handle_packet_with_unknown_apid(
             &mut self,
             sp_header: &SpHeader,
             tc_raw: &[u8],