rust/sat-rs
6
1
Fork 0
Code Issues 9 Pull Requests 1 Projects Releases 29 Wiki Activity

add some more tests

Browse Source
This commit is contained in:
Robin Mueller
2025-11-27 12:23:36 +01:00
parent f9fafd4cd8
commit 01c5362473
1 changed files with 193 additions and 27 deletions
Download Patch File Download Diff File Expand all files Collapse all files

220
satrs/src/ccsds/scheduler.rs
View File

@@ -301,32 +301,29 @@ pub mod alloc_mod {
/// Delete all telecommands scheduled in a time window.
///
/// Returns whether any telecommands were deleted.
pub fn delete_from_start_to_end(
&mut self,
start_time: UnixTime,
end_time: UnixTime,
) -> bool {
/// The range includes the start time but excludes the end time. Returns whether any
/// telecommands were deleted.
pub fn delete_in_time_window(&mut self, start_time: UnixTime, end_time: UnixTime) -> bool {
let len_before = self.tc_map.len();
self.tc_map.retain(|k, _| k < &start_time || k > &end_time);
self.tc_map.retain(|k, _| k < &start_time || k >= &end_time);
self.tc_map.len() < len_before
}
/// Delete all scheduled telecommands starting from a given time.
/// Delete all scheduled telecommands scheduled after or at a given time.
///
/// Returns whether any telecommands were deleted.
pub fn delete_from_start(&mut self, start_time: UnixTime) -> bool {
pub fn delete_all_starting_at(&mut self, start_time: UnixTime) -> bool {
let len_before = self.tc_map.len();
self.tc_map.retain(|k, _| k < &start_time);
self.tc_map.len() < len_before
}
/// Delete all scheduled telecommands scheduled before a given time.
/// Delete all scheduled telecommands scheduled before but not equal to a given time.
///
/// Returns whether any telecommands were deleted.
pub fn delete_until_end(&mut self, end_time: UnixTime) -> bool {
pub fn delete_all_before(&mut self, end_time: UnixTime) -> bool {
let len_before = self.tc_map.len();
self.tc_map.retain(|k, _| k > &end_time);
self.tc_map.retain(|k, _| k >= &end_time);
self.tc_map.len() < len_before
}
@@ -339,16 +336,21 @@ pub mod alloc_mod {
#[cfg(test)]
mod tests {
use arbitrary_int::u11;
use arbitrary_int::{traits::Integer, u11, u14};
use spacepackets::{
CcsdsPacketCreatorOwned, CcsdsPacketReader, ChecksumType, SpacePacketHeader,
};
use super::*;
fn test_tc(app_data: &[u8]) -> CcsdsPacketCreatorOwned {
fn test_tc(app_data: &[u8], seq_count: u14) -> CcsdsPacketCreatorOwned {
CcsdsPacketCreatorOwned::new(
SpacePacketHeader::new_from_apid(u11::new(0x1)),
SpacePacketHeader::new_for_tc(
u11::new(0x1),
spacepackets::SequenceFlags::Unsegmented,
seq_count,
0,
),
spacepackets::PacketType::Tc,
app_data,
Some(ChecksumType::WithCrc16),
@@ -403,7 +405,7 @@ mod tests {
Limits::new(Some(100), Some(1024)),
Duration::from_millis(1000),
);
let test_tc = test_tc(&[1, 2, 3]);
let test_tc = test_tc(&[1, 2, 3], u14::ZERO);
let test_tc_raw = test_tc.to_vec();
let reader = CcsdsPacketReader::new(&test_tc_raw, Some(ChecksumType::WithCrc16)).unwrap();
scheduler
@@ -440,9 +442,9 @@ mod tests {
Limits::new(Some(100), Some(1024)),
Duration::from_millis(1000),
);
let test_tc = test_tc(&[1, 2, 3]);
let tc_id = CcsdsPacketIdAndPsc::new_from_ccsds_packet(&test_tc);
let test_tc_raw = test_tc.to_vec();
let test_tc_0 = test_tc(&[1, 2, 3], u14::ZERO);
let tc_id = CcsdsPacketIdAndPsc::new_from_ccsds_packet(&test_tc_0);
let test_tc_raw = test_tc_0.to_vec();
let reader = CcsdsPacketReader::new(&test_tc_raw, Some(ChecksumType::WithCrc16)).unwrap();
let checksum = reader.checksum();
scheduler
@@ -484,15 +486,15 @@ mod tests {
}
#[test]
fn insert_and_release_multi() {
fn insert_and_release_multi_0() {
let unix_time = UnixTime::new(0, 0);
let mut scheduler = CcsdsScheduler::new(
unix_time,
Limits::new(Some(100), Some(1024)),
Duration::from_millis(1000),
);
let test_tc_0 = test_tc(&[42]);
let test_tc_1 = test_tc(&[1, 2, 3]);
let test_tc_0 = test_tc(&[42], u14::ZERO);
let test_tc_1 = test_tc(&[1, 2, 3], u14::new(1));
let tc_id_0 = CcsdsPacketIdAndPsc::new_from_ccsds_packet(&test_tc_0);
let tc_id_1 = CcsdsPacketIdAndPsc::new_from_ccsds_packet(&test_tc_1);
let test_tc_0_raw = test_tc_0.to_vec();
@@ -579,6 +581,85 @@ mod tests {
assert_eq!(scheduler.num_of_entries(), 0);
}
#[test]
fn insert_and_release_multi_1() {
let unix_time = UnixTime::new(0, 0);
let mut scheduler = CcsdsScheduler::new(
unix_time,
Limits::new(Some(100), Some(1024)),
Duration::from_millis(1000),
);
let test_tc_0 = test_tc(&[42], u14::ZERO);
let test_tc_1 = test_tc(&[1, 2, 3], u14::new(1));
let tc_id_0 = CcsdsPacketIdAndPsc::new_from_ccsds_packet(&test_tc_0);
let tc_id_1 = CcsdsPacketIdAndPsc::new_from_ccsds_packet(&test_tc_1);
let test_tc_0_raw = test_tc_0.to_vec();
let test_tc_1_raw = test_tc_1.to_vec();
let reader_0 =
CcsdsPacketReader::new(&test_tc_0_raw, Some(ChecksumType::WithCrc16)).unwrap();
let reader_1 =
CcsdsPacketReader::new(&test_tc_1_raw, Some(ChecksumType::WithCrc16)).unwrap();
scheduler
.insert_telecommand_with_reader(&reader_0, UnixTime::new(2, 0))
.unwrap();
scheduler
.insert_telecommand(
CcsdsSchedulePacketId::new(tc_id_1, reader_1.checksum()),
&test_tc_1_raw,
UnixTime::new(5, 0),
)
.unwrap();
assert_eq!(scheduler.current_fill_count().packets, 2);
assert_eq!(
scheduler.current_fill_count().bytes,
test_tc_0_raw.len() + test_tc_1_raw.len()
);
assert_eq!(scheduler.num_of_entries(), 2);
assert_eq!(
scheduler
.telecommands_to_release()
.collect::<alloc::vec::Vec<_>>()
.len(),
0
);
scheduler.release_telecommands(|_, _| {
panic!("should not be called");
});
// Release first TC.
scheduler.update_time(UnixTime::new(6, 0));
assert_eq!(
scheduler
.telecommands_to_release()
.collect::<alloc::vec::Vec<_>>()
.len(),
2
);
let mut index = 0;
scheduler.release_telecommands(|tc_id_scheduled, tc_raw| {
if index == 0 {
assert_eq!(tc_id_0, tc_id_scheduled.base);
assert_eq!(reader_0.checksum(), tc_id_scheduled.crc16);
assert_eq!(tc_raw, test_tc_0_raw);
} else {
assert_eq!(tc_id_1, tc_id_scheduled.base);
assert_eq!(reader_1.checksum(), tc_id_scheduled.crc16);
assert_eq!(tc_raw, test_tc_1_raw);
}
index += 1;
});
assert_eq!(
scheduler
.telecommands_to_release()
.collect::<alloc::vec::Vec<_>>()
.len(),
0
);
assert_eq!(scheduler.current_fill_count().packets, 0);
assert_eq!(scheduler.current_fill_count().bytes, 0);
assert_eq!(scheduler.num_of_entries(), 0);
}
#[test]
fn test_packet_limit_reached() {
let unix_time = UnixTime::new(0, 0);
@@ -587,7 +668,7 @@ mod tests {
Limits::new(Some(3), None),
Duration::from_millis(1000),
);
let test_tc_0 = test_tc(&[42]);
let test_tc_0 = test_tc(&[42], u14::ZERO);
let test_tc_0_raw = test_tc_0.to_vec();
let reader = CcsdsPacketReader::new(&test_tc_0_raw, Some(ChecksumType::WithCrc16)).unwrap();
let tc_id = CcsdsPacketIdAndPsc::new_from_ccsds_packet(&test_tc_0);
@@ -618,7 +699,7 @@ mod tests {
#[test]
fn test_byte_limit_reached() {
let unix_time = UnixTime::new(0, 0);
let test_tc_0 = test_tc(&[42]);
let test_tc_0 = test_tc(&[42], u14::ZERO);
let mut scheduler = CcsdsScheduler::new(
unix_time,
Limits::new(None, Some(test_tc_0.len_written() * 3)),
@@ -659,7 +740,7 @@ mod tests {
Limits::new(Some(100), Some(1024)),
Duration::from_millis(1000),
);
let test_tc = test_tc(&[1, 2, 3]);
let test_tc = test_tc(&[1, 2, 3], u14::ZERO);
let tc_id = CcsdsPacketIdAndPsc::new_from_ccsds_packet(&test_tc);
let test_tc_raw = test_tc.to_vec();
let reader = CcsdsPacketReader::new(&test_tc_raw, Some(ChecksumType::WithCrc16)).unwrap();
@@ -674,8 +755,93 @@ mod tests {
}
#[test]
fn test_deletion_by_window() {
//TODO
fn test_deletion_by_window_0() {
let unix_time = UnixTime::new(0, 0);
let mut scheduler = CcsdsScheduler::new(
unix_time,
Limits::new(Some(100), Some(1024)),
Duration::from_millis(1000),
);
let test_tc_0 = test_tc(&[42], u14::ZERO);
let test_tc_1 = test_tc(&[1, 2, 3], u14::new(1));
let test_tc_2 = test_tc(&[1, 2, 3], u14::new(2));
let test_tc_0_raw = test_tc_0.to_vec();
let test_tc_1_raw = test_tc_1.to_vec();
let test_tc_2_raw = test_tc_2.to_vec();
let reader_0 =
CcsdsPacketReader::new(&test_tc_0_raw, Some(ChecksumType::WithCrc16)).unwrap();
let reader_1 =
CcsdsPacketReader::new(&test_tc_1_raw, Some(ChecksumType::WithCrc16)).unwrap();
let reader_2 =
CcsdsPacketReader::new(&test_tc_2_raw, Some(ChecksumType::WithCrc16)).unwrap();
scheduler
.insert_telecommand_with_reader(&reader_0, UnixTime::new(2, 0))
.unwrap();
scheduler
.insert_telecommand_with_reader(&reader_1, UnixTime::new(5, 0))
.unwrap();
scheduler
.insert_telecommand_with_reader(&reader_2, UnixTime::new(7, 0))
.unwrap();
let deleted = scheduler.delete_in_time_window(UnixTime::new(3, 0), UnixTime::new(6, 0));
assert!(deleted);
assert_eq!(scheduler.current_fill_count().packets, 2);
assert_eq!(
scheduler.current_fill_count().bytes,
test_tc_0_raw.len() + test_tc_2_raw.len()
);
scheduler.update_time(UnixTime::new(10, 0));
let mut index = 0;
scheduler.release_telecommands(|_id, packet| {
if index == 0 {
assert_eq!(packet, test_tc_0_raw);
} else {
assert_eq!(packet, test_tc_2_raw);
}
index += 1;
});
assert_eq!(scheduler.current_fill_count().packets, 0);
assert_eq!(scheduler.current_fill_count().bytes, 0);
}
#[test]
fn test_deletion_by_window_1() {
let unix_time = UnixTime::new(0, 0);
let mut scheduler = CcsdsScheduler::new(
unix_time,
Limits::new(Some(100), Some(1024)),
Duration::from_millis(1000),
);
let test_tc_0 = test_tc(&[42], u14::ZERO);
let test_tc_1 = test_tc(&[1, 2, 3], u14::new(1));
let test_tc_2 = test_tc(&[1, 2, 3], u14::new(2));
let test_tc_0_raw = test_tc_0.to_vec();
let test_tc_1_raw = test_tc_1.to_vec();
let test_tc_2_raw = test_tc_2.to_vec();
let reader_0 =
CcsdsPacketReader::new(&test_tc_0_raw, Some(ChecksumType::WithCrc16)).unwrap();
let reader_1 =
CcsdsPacketReader::new(&test_tc_1_raw, Some(ChecksumType::WithCrc16)).unwrap();
let reader_2 =
CcsdsPacketReader::new(&test_tc_2_raw, Some(ChecksumType::WithCrc16)).unwrap();
scheduler
.insert_telecommand_with_reader(&reader_0, UnixTime::new(2, 0))
.unwrap();
scheduler
.insert_telecommand_with_reader(&reader_1, UnixTime::new(5, 0))
.unwrap();
scheduler
.insert_telecommand_with_reader(&reader_2, UnixTime::new(7, 0))
.unwrap();
// This only deletes the first 2 TCs.
let deleted = scheduler.delete_in_time_window(UnixTime::new(2, 0), UnixTime::new(7, 0));
assert!(deleted);
assert_eq!(scheduler.current_fill_count().packets, 1);
assert_eq!(scheduler.current_fill_count().bytes, test_tc_2_raw.len());
scheduler.update_time(UnixTime::new(10, 0));
scheduler.release_telecommands(|_id, packet| {
assert_eq!(packet, test_tc_2_raw);
});
}
#[test]