From cc1f3ed091fe7c5042e7e91ef4d4c569b1612281 Mon Sep 17 00:00:00 2001 From: Robin Mueller Date: Tue, 1 Nov 2022 18:03:01 +0100 Subject: [PATCH] basic unittests for PUS event man --- fsrc-core/src/events.rs | 24 +++++++ fsrc-core/src/pus/event_man.rs | 109 ++++++++++++++++++++++++++++++ fsrc-core/src/pus/verification.rs | 3 +- fsrc-core/tests/pus_events.rs | 21 ++++-- 4 files changed, 150 insertions(+), 7 deletions(-) diff --git a/fsrc-core/src/events.rs b/fsrc-core/src/events.rs index 8920a12..d0ea2f2 100644 --- a/fsrc-core/src/events.rs +++ b/fsrc-core/src/events.rs @@ -285,6 +285,18 @@ impl From> for EventU32 { } } +impl AsRef for EventU32TypedSev { + fn as_ref(&self) -> &EventU32 { + &self.event + } +} + +impl AsMut for EventU32TypedSev { + fn as_mut(&mut self) -> &mut EventU32 { + &mut self.event + } +} + impl_event_provider!(EventU32, EventU32TypedSev, u32, u16, u16); impl EventU32 { @@ -423,6 +435,18 @@ pub struct EventU16TypedSev { phantom: PhantomData, } +impl AsRef for EventU16TypedSev { + fn as_ref(&self) -> &EventU16 { + &self.event + } +} + +impl AsMut for EventU16TypedSev { + fn as_mut(&mut self) -> &mut EventU16 { + &mut self.event + } +} + impl EventU16 { /// Generate a small event. The raw representation of a small event has 16 bits. /// If the passed group ID is invalid (too large), [None] wil be returned diff --git a/fsrc-core/src/pus/event_man.rs b/fsrc-core/src/pus/event_man.rs index 33d860f..11075d9 100644 --- a/fsrc-core/src/pus/event_man.rs +++ b/fsrc-core/src/pus/event_man.rs @@ -174,6 +174,20 @@ impl PusEventTmManager { } impl PusEventTmManager { + pub fn enable_tm_for_event_with_sev( + &mut self, + event: &EventU32TypedSev, + ) -> Result { + self.backend.enable_event_reporting(event.as_ref()) + } + + pub fn disable_tm_for_event_with_sev( + &mut self, + event: &EventU32TypedSev, + ) -> Result { + self.backend.disable_event_reporting(event.as_ref()) + } + pub fn generate_pus_event_tm( &mut self, sender: &mut (impl EcssTmSender + ?Sized), @@ -190,3 +204,98 @@ impl PusEventTmManager { ) } } + +#[cfg(test)] +mod tests { + use super::*; + use crate::events::SeverityInfo; + use spacepackets::tm::PusTm; + use std::sync::mpsc::{channel, SendError, TryRecvError}; + use std::vec::Vec; + + const INFO_EVENT: EventU32TypedSev = + EventU32TypedSev::::const_new(1, 0); + const LOW_SEV_EVENT: EventU32 = EventU32::const_new(Severity::LOW, 1, 5); + const EMPTY_STAMP: [u8; 7] = [0; 7]; + + struct EventTmSender { + sender: std::sync::mpsc::Sender>, + } + + impl EcssTmSender for EventTmSender { + type Error = SendError>; + fn send_tm(&mut self, tm: PusTm) -> Result<(), EcssTmError> { + let mut vec = Vec::new(); + tm.append_to_vec(&mut vec)?; + self.sender.send(vec).map_err(EcssTmError::SendError)?; + Ok(()) + } + } + + fn create_basic_man() -> PusEventTmManager<(), EventU32> { + let reporter = EventReporter::new(0x02, 128).expect("Creating event repoter failed"); + let backend = DefaultPusMgmtBackendProvider::::default(); + PusEventTmManager::new(reporter, Box::new(backend)) + } + + #[test] + fn test_basic() { + let mut event_man = create_basic_man(); + let (event_tx, event_rx) = channel(); + let mut sender = EventTmSender { sender: event_tx }; + let event_sent = event_man + .generate_pus_event_tm(&mut sender, &EMPTY_STAMP, INFO_EVENT, None) + .expect("Sending info event failed"); + + assert!(event_sent); + // Will not check packet here, correctness of packet was tested somewhere else + event_rx.try_recv().expect("Receiving event TM failed"); + } + + #[test] + fn test_disable_event() { + let mut event_man = create_basic_man(); + let (event_tx, event_rx) = channel(); + let mut sender = EventTmSender { sender: event_tx }; + let res = event_man.disable_tm_for_event(&LOW_SEV_EVENT); + assert!(res.is_ok()); + assert!(res.unwrap()); + let mut event_sent = event_man + .generate_pus_event_tm_generic( + Severity::LOW, + &mut sender, + &EMPTY_STAMP, + LOW_SEV_EVENT, + None, + ) + .expect("Sending low severity event failed"); + assert!(!event_sent); + let res = event_rx.try_recv(); + assert!(res.is_err()); + assert!(matches!(res.unwrap_err(), TryRecvError::Empty)); + // Check that only the low severity event was disabled + event_sent = event_man + .generate_pus_event_tm(&mut sender, &EMPTY_STAMP, INFO_EVENT, None) + .expect("Sending info event failed"); + assert!(event_sent); + event_rx.try_recv().expect("No info event received"); + } + + #[test] + fn test_reenable_event() { + let mut event_man = create_basic_man(); + let (event_tx, event_rx) = channel(); + let mut sender = EventTmSender { sender: event_tx }; + let mut res = event_man.disable_tm_for_event_with_sev(&INFO_EVENT); + assert!(res.is_ok()); + assert!(res.unwrap()); + res = event_man.enable_tm_for_event_with_sev(&INFO_EVENT); + assert!(res.is_ok()); + assert!(res.unwrap()); + let event_sent = event_man + .generate_pus_event_tm(&mut sender, &EMPTY_STAMP, INFO_EVENT, None) + .expect("Sending info event failed"); + assert!(event_sent); + event_rx.try_recv().expect("No info event received"); + } +} diff --git a/fsrc-core/src/pus/verification.rs b/fsrc-core/src/pus/verification.rs index 996d558..0908b01 100644 --- a/fsrc-core/src/pus/verification.rs +++ b/fsrc-core/src/pus/verification.rs @@ -1131,7 +1131,8 @@ mod tests { #[derive(Default)] struct FallibleSender {} - impl EcssTmSender for FallibleSender { + impl EcssTmSender for FallibleSender { + type Error = DummyError; fn send_tm(&mut self, _: PusTm) -> Result<(), EcssTmError> { Err(EcssTmError::SendError(DummyError {})) } diff --git a/fsrc-core/tests/pus_events.rs b/fsrc-core/tests/pus_events.rs index e4faf35..0534e96 100644 --- a/fsrc-core/tests/pus_events.rs +++ b/fsrc-core/tests/pus_events.rs @@ -2,7 +2,7 @@ use fsrc_core::events::{EventU32, EventU32TypedSev, Severity, SeverityInfo}; use fsrc_core::pus::event_man::{DefaultPusMgmtBackendProvider, EventReporter, PusEventTmManager}; use fsrc_core::pus::{EcssTmError, EcssTmSender}; use spacepackets::tm::PusTm; -use std::sync::mpsc::{channel, SendError}; +use std::sync::mpsc::{channel, SendError, TryRecvError}; const INFO_EVENT: EventU32TypedSev = EventU32TypedSev::::const_new(1, 0); @@ -24,18 +24,27 @@ impl EcssTmSender for EventTmSender { } #[test] -fn main() { +fn test_basic() { let reporter = EventReporter::new(0x02, 128).expect("Creating event repoter failed"); let backend = DefaultPusMgmtBackendProvider::::default(); let mut event_man = PusEventTmManager::new(reporter, Box::new(backend)); let (event_tx, event_rx) = channel(); let mut sender = EventTmSender { sender: event_tx }; - let event_sent = event_man + let mut event_sent = event_man .generate_pus_event_tm(&mut sender, &EMPTY_STAMP, INFO_EVENT, None) .expect("Sending info event failed"); assert!(event_sent); - let packet = event_rx.recv().expect("Receiving event TM failed"); - println!("{:?}", packet); - //let event_man; + // Will not check packet here, correctness of packet was tested somewhere else + event_rx.recv().expect("Receiving event TM failed"); + let res = event_man.disable_tm_for_event_with_sev(&INFO_EVENT); + assert!(res.is_ok()); + assert!(res.unwrap()); + event_sent = event_man + .generate_pus_event_tm(&mut sender, &EMPTY_STAMP, INFO_EVENT, None) + .expect("Sending info event failed"); + assert!(!event_sent); + let res = event_rx.try_recv(); + assert!(res.is_err()); + assert!(matches!(res.unwrap_err(), TryRecvError::Empty)); }