refactored verification reporter

- Use generics instead of trait objects where applicable.

satrs-example/src/pus/action.rs

@@ -2,14 +2,16 @@ use log::{error, warn};
 use satrs::action::ActionRequest;
 use satrs::pool::{SharedStaticMemoryPool, StoreAddr};
 use satrs::pus::action::{PusActionToRequestConverter, PusService8ActionHandler};
+use satrs::pus::verification::std_mod::{
+    VerificationReporterWithSharedPoolMpscBoundedSender, VerificationReporterWithVecMpscSender,
+};
 use satrs::pus::verification::{
-    FailParams, TcStateAccepted, VerificationReporterWithSender, VerificationReportingProvider,
-    VerificationToken,
+    FailParams, TcStateAccepted, VerificationReportingProvider, VerificationToken,
 };
 use satrs::pus::{
     EcssTcAndToken, EcssTcInMemConverter, EcssTcInSharedStoreConverter, EcssTcInVecConverter,
-    MpscTcReceiver, MpscTmAsVecSender, MpscTmInSharedPoolSender, PusPacketHandlerResult,
-    PusPacketHandlingError, PusServiceHelper,
+    MpscTcReceiver, PusPacketHandlerResult, PusPacketHandlingError, PusServiceHelper,
+    TmAsVecSenderWithId, TmInSharedPoolSenderWithId,
 };
 use satrs::request::TargetAndApidId;
 use satrs::spacepackets::ecss::tc::PusTcReader;
@@ -74,13 +76,14 @@ impl PusActionToRequestConverter for ExampleActionRequestConverter {
 
 pub fn create_action_service_static(
     shared_tm_store: SharedTmPool,
-    tm_funnel_tx: mpsc::Sender<StoreAddr>,
-    verif_reporter: VerificationReporterWithSender,
+    tm_funnel_tx: mpsc::SyncSender<StoreAddr>,
+    verif_reporter: VerificationReporterWithSharedPoolMpscBoundedSender,
     tc_pool: SharedStaticMemoryPool,
     pus_action_rx: mpsc::Receiver<EcssTcAndToken>,
     action_router: GenericRequestRouter,
-) -> Pus8Wrapper<EcssTcInSharedStoreConverter> {
-    let action_srv_tm_sender = MpscTmInSharedPoolSender::new(
+) -> Pus8Wrapper<EcssTcInSharedStoreConverter, VerificationReporterWithSharedPoolMpscBoundedSender>
+{
+    let action_srv_tm_sender = TmInSharedPoolSenderWithId::new(
         TmSenderId::PusAction as ChannelId,
         "PUS_8_TM_SENDER",
         shared_tm_store.clone(),
@@ -108,11 +111,11 @@ pub fn create_action_service_static(
 
 pub fn create_action_service_dynamic(
     tm_funnel_tx: mpsc::Sender<Vec<u8>>,
-    verif_reporter: VerificationReporterWithSender,
+    verif_reporter: VerificationReporterWithVecMpscSender,
     pus_action_rx: mpsc::Receiver<EcssTcAndToken>,
     action_router: GenericRequestRouter,
-) -> Pus8Wrapper<EcssTcInVecConverter> {
-    let action_srv_tm_sender = MpscTmAsVecSender::new(
+) -> Pus8Wrapper<EcssTcInVecConverter, VerificationReporterWithVecMpscSender> {
+    let action_srv_tm_sender = TmAsVecSenderWithId::new(
         TmSenderId::PusAction as ChannelId,
         "PUS_8_TM_SENDER",
         tm_funnel_tx.clone(),
@@ -137,17 +140,24 @@ pub fn create_action_service_dynamic(
     Pus8Wrapper { pus_8_handler }
 }
 
-pub struct Pus8Wrapper<TcInMemConverter: EcssTcInMemConverter> {
+pub struct Pus8Wrapper<
+    TcInMemConverter: EcssTcInMemConverter,
+    VerificationReporter: VerificationReportingProvider,
+> {
     pub(crate) pus_8_handler: PusService8ActionHandler<
         TcInMemConverter,
-        VerificationReporterWithSender,
+        VerificationReporter,
         ExampleActionRequestConverter,
         GenericRequestRouter,
         GenericRoutingErrorHandler<8>,
     >,
 }
 
-impl<TcInMemConverter: EcssTcInMemConverter> Pus8Wrapper<TcInMemConverter> {
+impl<
+        TcInMemConverter: EcssTcInMemConverter,
+        VerificationReporter: VerificationReportingProvider,
+    > Pus8Wrapper<TcInMemConverter, VerificationReporter>
+{
     pub fn handle_next_packet(&mut self) -> bool {
         match self.pus_8_handler.handle_one_tc() {
             Ok(result) => match result {

satrs-example/src/pus/event.rs

@@ -4,11 +4,14 @@ use log::{error, warn};
 use satrs::pool::{SharedStaticMemoryPool, StoreAddr};
 use satrs::pus::event_man::EventRequestWithToken;
 use satrs::pus::event_srv::PusService5EventHandler;
-use satrs::pus::verification::VerificationReporterWithSender;
+use satrs::pus::verification::std_mod::{
+    VerificationReporterWithSharedPoolMpscBoundedSender, VerificationReporterWithVecMpscSender,
+};
+use satrs::pus::verification::VerificationReportingProvider;
 use satrs::pus::{
     EcssTcAndToken, EcssTcInMemConverter, EcssTcInSharedStoreConverter, EcssTcInVecConverter,
-    MpscTcReceiver, MpscTmAsVecSender, MpscTmInSharedPoolSender, PusPacketHandlerResult,
-    PusServiceHelper,
+    MpscTcReceiver, PusPacketHandlerResult, PusServiceHelper, TmAsVecSenderWithId,
+    TmInSharedPoolSenderWithId,
 };
 use satrs::tmtc::tm_helper::SharedTmPool;
 use satrs::ChannelId;
@@ -16,13 +19,14 @@ use satrs_example::config::{TcReceiverId, TmSenderId, PUS_APID};
 
 pub fn create_event_service_static(
     shared_tm_store: SharedTmPool,
-    tm_funnel_tx: mpsc::Sender<StoreAddr>,
-    verif_reporter: VerificationReporterWithSender,
+    tm_funnel_tx: mpsc::SyncSender<StoreAddr>,
+    verif_reporter: VerificationReporterWithSharedPoolMpscBoundedSender,
     tc_pool: SharedStaticMemoryPool,
     pus_event_rx: mpsc::Receiver<EcssTcAndToken>,
     event_request_tx: mpsc::Sender<EventRequestWithToken>,
-) -> Pus5Wrapper<EcssTcInSharedStoreConverter> {
-    let event_srv_tm_sender = MpscTmInSharedPoolSender::new(
+) -> Pus5Wrapper<EcssTcInSharedStoreConverter, VerificationReporterWithSharedPoolMpscBoundedSender>
+{
+    let event_srv_tm_sender = TmInSharedPoolSenderWithId::new(
         TmSenderId::PusEvent as ChannelId,
         "PUS_5_TM_SENDER",
         shared_tm_store.clone(),
@@ -48,11 +52,11 @@ pub fn create_event_service_static(
 
 pub fn create_event_service_dynamic(
     tm_funnel_tx: mpsc::Sender<Vec<u8>>,
-    verif_reporter: VerificationReporterWithSender,
+    verif_reporter: VerificationReporterWithVecMpscSender,
     pus_event_rx: mpsc::Receiver<EcssTcAndToken>,
     event_request_tx: mpsc::Sender<EventRequestWithToken>,
-) -> Pus5Wrapper<EcssTcInVecConverter> {
-    let event_srv_tm_sender = MpscTmAsVecSender::new(
+) -> Pus5Wrapper<EcssTcInVecConverter, VerificationReporterWithVecMpscSender> {
+    let event_srv_tm_sender = TmAsVecSenderWithId::new(
         TmSenderId::PusEvent as ChannelId,
         "PUS_5_TM_SENDER",
         tm_funnel_tx,
@@ -75,11 +79,18 @@ pub fn create_event_service_dynamic(
     Pus5Wrapper { pus_5_handler }
 }
 
-pub struct Pus5Wrapper<TcInMemConverter: EcssTcInMemConverter> {
-    pub pus_5_handler: PusService5EventHandler<TcInMemConverter, VerificationReporterWithSender>,
+pub struct Pus5Wrapper<
+    TcInMemConverter: EcssTcInMemConverter,
+    VerificationReporter: VerificationReportingProvider,
+> {
+    pub pus_5_handler: PusService5EventHandler<TcInMemConverter, VerificationReporter>,
 }
 
-impl<TcInMemConverter: EcssTcInMemConverter> Pus5Wrapper<TcInMemConverter> {
+impl<
+        TcInMemConverter: EcssTcInMemConverter,
+        VerificationReporter: VerificationReportingProvider,
+    > Pus5Wrapper<TcInMemConverter, VerificationReporter>
+{
     pub fn handle_next_packet(&mut self) -> bool {
         match self.pus_5_handler.handle_one_tc() {
             Ok(result) => match result {

satrs-example/src/pus/hk.rs

@@ -2,14 +2,16 @@ use log::{error, warn};
 use satrs::hk::{CollectionIntervalFactor, HkRequest};
 use satrs::pool::{SharedStaticMemoryPool, StoreAddr};
 use satrs::pus::hk::{PusHkToRequestConverter, PusService3HkHandler};
+use satrs::pus::verification::std_mod::{
+    VerificationReporterWithSharedPoolMpscBoundedSender, VerificationReporterWithVecMpscSender,
+};
 use satrs::pus::verification::{
-    FailParams, TcStateAccepted, VerificationReporterWithSender, VerificationReportingProvider,
-    VerificationToken,
+    FailParams, TcStateAccepted, VerificationReportingProvider, VerificationToken,
 };
 use satrs::pus::{
     EcssTcAndToken, EcssTcInMemConverter, EcssTcInSharedStoreConverter, EcssTcInVecConverter,
-    MpscTcReceiver, MpscTmAsVecSender, MpscTmInSharedPoolSender, PusPacketHandlerResult,
-    PusPacketHandlingError, PusServiceHelper,
+    MpscTcReceiver, PusPacketHandlerResult, PusPacketHandlingError, PusServiceHelper,
+    TmAsVecSenderWithId, TmInSharedPoolSenderWithId,
 };
 use satrs::request::TargetAndApidId;
 use satrs::spacepackets::ecss::tc::PusTcReader;
@@ -143,13 +145,14 @@ impl PusHkToRequestConverter for ExampleHkRequestConverter {
 
 pub fn create_hk_service_static(
     shared_tm_store: SharedTmPool,
-    tm_funnel_tx: mpsc::Sender<StoreAddr>,
-    verif_reporter: VerificationReporterWithSender,
+    tm_funnel_tx: mpsc::SyncSender<StoreAddr>,
+    verif_reporter: VerificationReporterWithSharedPoolMpscBoundedSender,
     tc_pool: SharedStaticMemoryPool,
     pus_hk_rx: mpsc::Receiver<EcssTcAndToken>,
     request_router: GenericRequestRouter,
-) -> Pus3Wrapper<EcssTcInSharedStoreConverter> {
-    let hk_srv_tm_sender = MpscTmInSharedPoolSender::new(
+) -> Pus3Wrapper<EcssTcInSharedStoreConverter, VerificationReporterWithSharedPoolMpscBoundedSender>
+{
+    let hk_srv_tm_sender = TmInSharedPoolSenderWithId::new(
         TmSenderId::PusHk as ChannelId,
         "PUS_3_TM_SENDER",
         shared_tm_store.clone(),
@@ -174,11 +177,11 @@ pub fn create_hk_service_static(
 
 pub fn create_hk_service_dynamic(
     tm_funnel_tx: mpsc::Sender<Vec<u8>>,
-    verif_reporter: VerificationReporterWithSender,
+    verif_reporter: VerificationReporterWithVecMpscSender,
     pus_hk_rx: mpsc::Receiver<EcssTcAndToken>,
     request_router: GenericRequestRouter,
-) -> Pus3Wrapper<EcssTcInVecConverter> {
-    let hk_srv_tm_sender = MpscTmAsVecSender::new(
+) -> Pus3Wrapper<EcssTcInVecConverter, VerificationReporterWithVecMpscSender> {
+    let hk_srv_tm_sender = TmAsVecSenderWithId::new(
         TmSenderId::PusHk as ChannelId,
         "PUS_3_TM_SENDER",
         tm_funnel_tx.clone(),
@@ -200,17 +203,24 @@ pub fn create_hk_service_dynamic(
     Pus3Wrapper { pus_3_handler }
 }
 
-pub struct Pus3Wrapper<TcInMemConverter: EcssTcInMemConverter> {
+pub struct Pus3Wrapper<
+    TcInMemConverter: EcssTcInMemConverter,
+    VerificationReporter: VerificationReportingProvider,
+> {
     pub(crate) pus_3_handler: PusService3HkHandler<
         TcInMemConverter,
-        VerificationReporterWithSender,
+        VerificationReporter,
         ExampleHkRequestConverter,
         GenericRequestRouter,
         GenericRoutingErrorHandler<3>,
     >,
 }
 
-impl<TcInMemConverter: EcssTcInMemConverter> Pus3Wrapper<TcInMemConverter> {
+impl<
+        TcInMemConverter: EcssTcInMemConverter,
+        VerificationReporter: VerificationReportingProvider,
+    > Pus3Wrapper<TcInMemConverter, VerificationReporter>
+{
     pub fn handle_next_packet(&mut self) -> bool {
         match self.pus_3_handler.handle_one_tc() {
             Ok(result) => match result {

satrs-example/src/pus/mod.rs

@@ -1,8 +1,6 @@
 use crate::tmtc::MpscStoreAndSendError;
 use log::warn;
-use satrs::pus::verification::{
-    FailParams, StdVerifReporterWithSender, VerificationReportingProvider,
-};
+use satrs::pus::verification::{FailParams, VerificationReportingProvider};
 use satrs::pus::{
     EcssTcAndToken, GenericRoutingError, PusPacketHandlerResult, PusRoutingErrorHandler, TcInMemory,
 };
@@ -28,8 +26,8 @@ pub struct PusTcMpscRouter {
     pub action_service_receiver: Sender<EcssTcAndToken>,
 }
 
-pub struct PusReceiver {
-    pub verif_reporter: StdVerifReporterWithSender,
+pub struct PusReceiver<VerificationReporter: VerificationReportingProvider> {
+    pub verif_reporter: VerificationReporter,
     pub pus_router: PusTcMpscRouter,
     stamp_helper: TimeStampHelper,
 }
@@ -61,8 +59,8 @@ impl TimeStampHelper {
     }
 }
 
-impl PusReceiver {
-    pub fn new(verif_reporter: StdVerifReporterWithSender, pus_router: PusTcMpscRouter) -> Self {
+impl<VerificationReporter: VerificationReportingProvider> PusReceiver<VerificationReporter> {
+    pub fn new(verif_reporter: VerificationReporter, pus_router: PusTcMpscRouter) -> Self {
         Self {
             verif_reporter,
             pus_router,
@@ -71,7 +69,7 @@ impl PusReceiver {
     }
 }
 
-impl PusReceiver {
+impl<VerificationReporter: VerificationReportingProvider> PusReceiver<VerificationReporter> {
     pub fn handle_tc_packet(
         &mut self,
         tc_in_memory: TcInMemory,

satrs-example/src/pus/scheduler.rs

@@ -5,11 +5,14 @@ use log::{error, info, warn};
 use satrs::pool::{PoolProvider, StaticMemoryPool, StoreAddr};
 use satrs::pus::scheduler::{PusScheduler, TcInfo};
 use satrs::pus::scheduler_srv::PusService11SchedHandler;
-use satrs::pus::verification::VerificationReporterWithSender;
+use satrs::pus::verification::std_mod::{
+    VerificationReporterWithSharedPoolMpscBoundedSender, VerificationReporterWithVecMpscSender,
+};
+use satrs::pus::verification::VerificationReportingProvider;
 use satrs::pus::{
     EcssTcAndToken, EcssTcInMemConverter, EcssTcInSharedStoreConverter, EcssTcInVecConverter,
-    MpscTcReceiver, MpscTmAsVecSender, MpscTmInSharedPoolSender, PusPacketHandlerResult,
-    PusServiceHelper,
+    MpscTcReceiver, PusPacketHandlerResult, PusServiceHelper, TmAsVecSenderWithId,
+    TmInSharedPoolSenderWithId,
 };
 use satrs::tmtc::tm_helper::SharedTmPool;
 use satrs::ChannelId;
@@ -51,15 +54,22 @@ impl TcReleaser for mpsc::Sender<Vec<u8>> {
     }
 }
 
-pub struct Pus11Wrapper<TcInMemConverter: EcssTcInMemConverter> {
+pub struct Pus11Wrapper<
+    TcInMemConverter: EcssTcInMemConverter,
+    VerificationReporter: VerificationReportingProvider,
+> {
     pub pus_11_handler:
-        PusService11SchedHandler<TcInMemConverter, VerificationReporterWithSender, PusScheduler>,
+        PusService11SchedHandler<TcInMemConverter, VerificationReporter, PusScheduler>,
     pub sched_tc_pool: StaticMemoryPool,
     pub releaser_buf: [u8; 4096],
     pub tc_releaser: Box<dyn TcReleaser + Send>,
 }
 
-impl<TcInMemConverter: EcssTcInMemConverter> Pus11Wrapper<TcInMemConverter> {
+impl<
+        TcInMemConverter: EcssTcInMemConverter,
+        VerificationReporter: VerificationReportingProvider,
+    > Pus11Wrapper<TcInMemConverter, VerificationReporter>
+{
     pub fn release_tcs(&mut self) {
         let releaser = |enabled: bool, info: &TcInfo, tc: &[u8]| -> bool {
             self.tc_releaser.release(enabled, info, tc)
@@ -110,13 +120,14 @@ impl<TcInMemConverter: EcssTcInMemConverter> Pus11Wrapper<TcInMemConverter> {
 
 pub fn create_scheduler_service_static(
     shared_tm_store: SharedTmPool,
-    tm_funnel_tx: mpsc::Sender<StoreAddr>,
-    verif_reporter: VerificationReporterWithSender,
+    tm_funnel_tx: mpsc::SyncSender<StoreAddr>,
+    verif_reporter: VerificationReporterWithSharedPoolMpscBoundedSender,
     tc_releaser: PusTcSourceProviderSharedPool,
     pus_sched_rx: mpsc::Receiver<EcssTcAndToken>,
     sched_tc_pool: StaticMemoryPool,
-) -> Pus11Wrapper<EcssTcInSharedStoreConverter> {
-    let sched_srv_tm_sender = MpscTmInSharedPoolSender::new(
+) -> Pus11Wrapper<EcssTcInSharedStoreConverter, VerificationReporterWithSharedPoolMpscBoundedSender>
+{
+    let sched_srv_tm_sender = TmInSharedPoolSenderWithId::new(
         TmSenderId::PusSched as ChannelId,
         "PUS_11_TM_SENDER",
         shared_tm_store.clone(),
@@ -149,12 +160,12 @@ pub fn create_scheduler_service_static(
 
 pub fn create_scheduler_service_dynamic(
     tm_funnel_tx: mpsc::Sender<Vec<u8>>,
-    verif_reporter: VerificationReporterWithSender,
+    verif_reporter: VerificationReporterWithVecMpscSender,
     tc_source_sender: mpsc::Sender<Vec<u8>>,
     pus_sched_rx: mpsc::Receiver<EcssTcAndToken>,
     sched_tc_pool: StaticMemoryPool,
-) -> Pus11Wrapper<EcssTcInVecConverter> {
-    let sched_srv_tm_sender = MpscTmAsVecSender::new(
+) -> Pus11Wrapper<EcssTcInVecConverter, VerificationReporterWithVecMpscSender> {
+    let sched_srv_tm_sender = TmAsVecSenderWithId::new(
         TmSenderId::PusSched as ChannelId,
         "PUS_11_TM_SENDER",
         tm_funnel_tx,

satrs-example/src/pus/stack.rs

@@ -1,25 +1,32 @@
-use satrs::pus::EcssTcInMemConverter;
+use satrs::pus::{verification::VerificationReportingProvider, EcssTcInMemConverter};
 
 use super::{
     action::Pus8Wrapper, event::Pus5Wrapper, hk::Pus3Wrapper, scheduler::Pus11Wrapper,
     test::Service17CustomWrapper,
 };
 
-pub struct PusStack<TcInMemConverter: EcssTcInMemConverter> {
-    event_srv: Pus5Wrapper<TcInMemConverter>,
-    hk_srv: Pus3Wrapper<TcInMemConverter>,
-    action_srv: Pus8Wrapper<TcInMemConverter>,
-    schedule_srv: Pus11Wrapper<TcInMemConverter>,
-    test_srv: Service17CustomWrapper<TcInMemConverter>,
+pub struct PusStack<
+    TcInMemConverter: EcssTcInMemConverter,
+    VerificationReporter: VerificationReportingProvider,
+> {
+    event_srv: Pus5Wrapper<TcInMemConverter, VerificationReporter>,
+    hk_srv: Pus3Wrapper<TcInMemConverter, VerificationReporter>,
+    action_srv: Pus8Wrapper<TcInMemConverter, VerificationReporter>,
+    schedule_srv: Pus11Wrapper<TcInMemConverter, VerificationReporter>,
+    test_srv: Service17CustomWrapper<TcInMemConverter, VerificationReporter>,
 }
 
-impl<TcInMemConverter: EcssTcInMemConverter> PusStack<TcInMemConverter> {
+impl<
+        TcInMemConverter: EcssTcInMemConverter,
+        VerificationReporter: VerificationReportingProvider,
+    > PusStack<TcInMemConverter, VerificationReporter>
+{
     pub fn new(
-        hk_srv: Pus3Wrapper<TcInMemConverter>,
-        event_srv: Pus5Wrapper<TcInMemConverter>,
-        action_srv: Pus8Wrapper<TcInMemConverter>,
-        schedule_srv: Pus11Wrapper<TcInMemConverter>,
-        test_srv: Service17CustomWrapper<TcInMemConverter>,
+        hk_srv: Pus3Wrapper<TcInMemConverter, VerificationReporter>,
+        event_srv: Pus5Wrapper<TcInMemConverter, VerificationReporter>,
+        action_srv: Pus8Wrapper<TcInMemConverter, VerificationReporter>,
+        schedule_srv: Pus11Wrapper<TcInMemConverter, VerificationReporter>,
+        test_srv: Service17CustomWrapper<TcInMemConverter, VerificationReporter>,
     ) -> Self {
         Self {
             event_srv,

satrs-example/src/pus/test.rs

@@ -2,12 +2,13 @@ use log::{info, warn};
 use satrs::params::Params;
 use satrs::pool::{SharedStaticMemoryPool, StoreAddr};
 use satrs::pus::test::PusService17TestHandler;
+use satrs::pus::verification::{FailParams, VerificationReportingProvider};
 use satrs::pus::verification::{
-    FailParams, VerificationReporterWithSender, VerificationReportingProvider,
+    VerificationReporterWithSharedPoolMpscBoundedSender, VerificationReporterWithVecMpscSender,
 };
 use satrs::pus::{
-    EcssTcAndToken, EcssTcInMemConverter, EcssTcInVecConverter, MpscTcReceiver, MpscTmAsVecSender,
-    MpscTmInSharedPoolSender, PusPacketHandlerResult, PusServiceHelper,
+    EcssTcAndToken, EcssTcInMemConverter, EcssTcInVecConverter, MpscTcReceiver,
+    PusPacketHandlerResult, PusServiceHelper, TmAsVecSenderWithId, TmInSharedPoolSenderWithId,
 };
 use satrs::spacepackets::ecss::tc::PusTcReader;
 use satrs::spacepackets::ecss::PusPacket;
@@ -21,13 +22,16 @@ use std::sync::mpsc::{self, Sender};
 
 pub fn create_test_service_static(
     shared_tm_store: SharedTmPool,
-    tm_funnel_tx: mpsc::Sender<StoreAddr>,
-    verif_reporter: VerificationReporterWithSender,
+    tm_funnel_tx: mpsc::SyncSender<StoreAddr>,
+    verif_reporter: VerificationReporterWithSharedPoolMpscBoundedSender,
     tc_pool: SharedStaticMemoryPool,
     event_sender: mpsc::Sender<(EventU32, Option<Params>)>,
     pus_test_rx: mpsc::Receiver<EcssTcAndToken>,
-) -> Service17CustomWrapper<EcssTcInSharedStoreConverter> {
-    let test_srv_tm_sender = MpscTmInSharedPoolSender::new(
+) -> Service17CustomWrapper<
+    EcssTcInSharedStoreConverter,
+    VerificationReporterWithSharedPoolMpscBoundedSender,
+> {
+    let test_srv_tm_sender = TmInSharedPoolSenderWithId::new(
         TmSenderId::PusTest as ChannelId,
         "PUS_17_TM_SENDER",
         shared_tm_store.clone(),
@@ -53,11 +57,11 @@ pub fn create_test_service_static(
 
 pub fn create_test_service_dynamic(
     tm_funnel_tx: mpsc::Sender<Vec<u8>>,
-    verif_reporter: VerificationReporterWithSender,
+    verif_reporter: VerificationReporterWithVecMpscSender,
     event_sender: mpsc::Sender<(EventU32, Option<Params>)>,
     pus_test_rx: mpsc::Receiver<EcssTcAndToken>,
-) -> Service17CustomWrapper<EcssTcInVecConverter> {
-    let test_srv_tm_sender = MpscTmAsVecSender::new(
+) -> Service17CustomWrapper<EcssTcInVecConverter, VerificationReporterWithVecMpscSender> {
+    let test_srv_tm_sender = TmAsVecSenderWithId::new(
         TmSenderId::PusTest as ChannelId,
         "PUS_17_TM_SENDER",
         tm_funnel_tx.clone(),
@@ -80,12 +84,19 @@ pub fn create_test_service_dynamic(
     }
 }
 
-pub struct Service17CustomWrapper<TcInMemConverter: EcssTcInMemConverter> {
-    pub pus17_handler: PusService17TestHandler<TcInMemConverter, VerificationReporterWithSender>,
+pub struct Service17CustomWrapper<
+    TcInMemConverter: EcssTcInMemConverter,
+    VerificationReporter: VerificationReportingProvider,
+> {
+    pub pus17_handler: PusService17TestHandler<TcInMemConverter, VerificationReporter>,
     pub test_srv_event_sender: Sender<(EventU32, Option<Params>)>,
 }
 
-impl<TcInMemConverter: EcssTcInMemConverter> Service17CustomWrapper<TcInMemConverter> {
+impl<
+        TcInMemConverter: EcssTcInMemConverter,
+        VerificationReporter: VerificationReportingProvider,
+    > Service17CustomWrapper<TcInMemConverter, VerificationReporter>
+{
     pub fn handle_next_packet(&mut self) -> bool {
         let res = self.pus17_handler.handle_one_tc();
         if res.is_err() {