move some tests

satrs-core/src/hal/std/tcp_with_cobs_server.rs

@@ -165,14 +165,12 @@ mod tests {
         thread,
     };
 
-    use crate::tmtc::{ReceivesTcCore, TmPacketSource};
+    use crate::{tmtc::{ReceivesTcCore, TmPacketSource}, hal::std::tcp_server::ServerConfig, parsers::tests::{SIMPLE_PACKET, INVERTED_PACKET}};
-    use alloc::{boxed::Box, collections::VecDeque, sync::Arc, vec::Vec};
+    use alloc::{collections::VecDeque, sync::Arc, vec::Vec, boxed::Box};
     use cobs::encode;
 
-    use super::{parse_buffer_for_cobs_encoded_packets, ServerConfig, TcpTmtcInCobsServer};
+    use super::TcpTmtcInCobsServer;
 
-    const SIMPLE_PACKET: [u8; 5] = [1, 2, 3, 4, 5];
-    const INVERTED_PACKET: [u8; 5] = [5, 4, 3, 2, 1];
 
     #[derive(Default, Clone)]
     struct SyncTcCacher {
@@ -188,20 +186,6 @@ mod tests {
         }
     }
 
-    #[derive(Default)]
-    struct TcCacher {
-        tc_queue: VecDeque<Vec<u8>>,
-    }
-
-    impl ReceivesTcCore for TcCacher {
-        type Error = ();
-
-        fn pass_tc(&mut self, tc_raw: &[u8]) -> Result<(), Self::Error> {
-            self.tc_queue.push_back(tc_raw.to_vec());
-            Ok(())
-        }
-    }
-
     #[derive(Default, Clone)]
     struct SyncTmSource {
         tm_queue: Arc<Mutex<VecDeque<Vec<u8>>>>,
@@ -243,163 +227,6 @@ mod tests {
         *current_idx += 1;
     }
 
-    #[test]
-    fn test_parsing_simple_packet() {
-        let mut test_sender = TcCacher::default();
-        let mut encoded_buf: [u8; 16] = [0; 16];
-        let mut current_idx = 0;
-        encode_simple_packet(&mut encoded_buf, &mut current_idx);
-        let mut next_read_idx = 0;
-        let packets = parse_buffer_for_cobs_encoded_packets(
-            &mut encoded_buf[0..current_idx],
-            &mut test_sender,
-            &mut next_read_idx,
-        )
-        .unwrap();
-        assert_eq!(packets, 1);
-        assert_eq!(test_sender.tc_queue.len(), 1);
-        let packet = &test_sender.tc_queue[0];
-        assert_eq!(packet, &SIMPLE_PACKET);
-    }
-
-    #[test]
-    fn test_parsing_consecutive_packets() {
-        let mut test_sender = TcCacher::default();
-        let mut encoded_buf: [u8; 16] = [0; 16];
-        let mut current_idx = 0;
-        encode_simple_packet(&mut encoded_buf, &mut current_idx);
-
-        // Second packet
-        encoded_buf[current_idx] = 0;
-        current_idx += 1;
-        current_idx += encode(&INVERTED_PACKET, &mut encoded_buf[current_idx..]);
-        encoded_buf[current_idx] = 0;
-        current_idx += 1;
-        let mut next_read_idx = 0;
-        let packets = parse_buffer_for_cobs_encoded_packets(
-            &mut encoded_buf[0..current_idx],
-            &mut test_sender,
-            &mut next_read_idx,
-        )
-        .unwrap();
-        assert_eq!(packets, 2);
-        assert_eq!(test_sender.tc_queue.len(), 2);
-        let packet0 = &test_sender.tc_queue[0];
-        assert_eq!(packet0, &SIMPLE_PACKET);
-        let packet1 = &test_sender.tc_queue[1];
-        assert_eq!(packet1, &INVERTED_PACKET);
-    }
-
-    #[test]
-    fn test_split_tail_packet_only() {
-        let mut test_sender = TcCacher::default();
-        let mut encoded_buf: [u8; 16] = [0; 16];
-        let mut current_idx = 0;
-        encode_simple_packet(&mut encoded_buf, &mut current_idx);
-        let mut next_read_idx = 0;
-        let packets = parse_buffer_for_cobs_encoded_packets(
-            // Cut off the sentinel byte at the end.
-            &mut encoded_buf[0..current_idx - 1],
-            &mut test_sender,
-            &mut next_read_idx,
-        )
-        .unwrap();
-        assert_eq!(packets, 0);
-        assert_eq!(test_sender.tc_queue.len(), 0);
-        assert_eq!(next_read_idx, 0);
-    }
-
-    fn generic_test_split_packet(cut_off: usize) {
-        let mut test_sender = TcCacher::default();
-        let mut encoded_buf: [u8; 16] = [0; 16];
-        assert!(cut_off < INVERTED_PACKET.len() + 1);
-        let mut current_idx = 0;
-        encode_simple_packet(&mut encoded_buf, &mut current_idx);
-        // Second packet
-        encoded_buf[current_idx] = 0;
-        let packet_start = current_idx;
-        current_idx += 1;
-        let encoded_len = encode(&INVERTED_PACKET, &mut encoded_buf[current_idx..]);
-        assert_eq!(encoded_len, 6);
-        current_idx += encoded_len;
-        // We cut off the sentinel byte, so we expecte the write index to be the length of the
-        // packet minus the sentinel byte plus the first sentinel byte.
-        let next_expected_write_idx = 1 + encoded_len - cut_off + 1;
-        encoded_buf[current_idx] = 0;
-        current_idx += 1;
-        let mut next_write_idx = 0;
-        let expected_at_start = encoded_buf[packet_start..current_idx - cut_off].to_vec();
-        let packets = parse_buffer_for_cobs_encoded_packets(
-            // Cut off the sentinel byte at the end.
-            &mut encoded_buf[0..current_idx - cut_off],
-            &mut test_sender,
-            &mut next_write_idx,
-        )
-        .unwrap();
-        assert_eq!(packets, 1);
-        assert_eq!(test_sender.tc_queue.len(), 1);
-        assert_eq!(&test_sender.tc_queue[0], &SIMPLE_PACKET);
-        assert_eq!(next_write_idx, next_expected_write_idx);
-        assert_eq!(encoded_buf[..next_expected_write_idx], expected_at_start);
-    }
-
-    #[test]
-    fn test_one_packet_and_split_tail_packet_0() {
-        generic_test_split_packet(1);
-    }
-
-    #[test]
-    fn test_one_packet_and_split_tail_packet_1() {
-        generic_test_split_packet(2);
-    }
-
-    #[test]
-    fn test_one_packet_and_split_tail_packet_2() {
-        generic_test_split_packet(3);
-    }
-
-    #[test]
-    fn test_zero_at_end() {
-        let mut test_sender = TcCacher::default();
-        let mut encoded_buf: [u8; 16] = [0; 16];
-        let mut next_write_idx = 0;
-        let mut current_idx = 0;
-        encoded_buf[current_idx] = 5;
-        current_idx += 1;
-        encode_simple_packet(&mut encoded_buf, &mut current_idx);
-        encoded_buf[current_idx] = 0;
-        current_idx += 1;
-        let packets = parse_buffer_for_cobs_encoded_packets(
-            // Cut off the sentinel byte at the end.
-            &mut encoded_buf[0..current_idx],
-            &mut test_sender,
-            &mut next_write_idx,
-        )
-        .unwrap();
-        assert_eq!(packets, 1);
-        assert_eq!(test_sender.tc_queue.len(), 1);
-        assert_eq!(&test_sender.tc_queue[0], &SIMPLE_PACKET);
-        assert_eq!(next_write_idx, 1);
-        assert_eq!(encoded_buf[0], 0);
-    }
-
-    #[test]
-    fn test_all_zeroes() {
-        let mut test_sender = TcCacher::default();
-        let mut all_zeroes: [u8; 5] = [0; 5];
-        let mut next_write_idx = 0;
-        let packets = parse_buffer_for_cobs_encoded_packets(
-            // Cut off the sentinel byte at the end.
-            &mut all_zeroes,
-            &mut test_sender,
-            &mut next_write_idx,
-        )
-        .unwrap();
-        assert_eq!(packets, 0);
-        assert!(test_sender.tc_queue.is_empty());
-        assert_eq!(next_write_idx, 0);
-    }
-
     fn generic_tmtc_server(
         addr: &SocketAddr,
         tc_receiver: SyncTcCacher,

satrs-core/src/parsers.rs

@@ -129,3 +129,195 @@ pub fn parse_buffer_for_ccsds_space_packets<E>(
     }
     Ok(packets_found)
 }
+
+#[cfg(test)]
+pub(crate) mod tests {
+    use alloc::{collections::VecDeque, vec::Vec};
+    use cobs::encode;
+
+    use crate::tmtc::ReceivesTcCore;
+
+    use super::parse_buffer_for_cobs_encoded_packets;
+
+    pub(crate) const SIMPLE_PACKET: [u8; 5] = [1, 2, 3, 4, 5];
+    pub(crate) const INVERTED_PACKET: [u8; 5] = [5, 4, 3, 2, 1];
+
+    #[derive(Default)]
+    struct TcCacher {
+        tc_queue: VecDeque<Vec<u8>>,
+    }
+
+    impl ReceivesTcCore for TcCacher {
+        type Error = ();
+
+        fn pass_tc(&mut self, tc_raw: &[u8]) -> Result<(), Self::Error> {
+            self.tc_queue.push_back(tc_raw.to_vec());
+            Ok(())
+        }
+    }
+
+    pub (crate) fn encode_simple_packet(encoded_buf: &mut [u8], current_idx: &mut usize) {
+        encoded_buf[*current_idx] = 0;
+        *current_idx += 1;
+        *current_idx += encode(&SIMPLE_PACKET, &mut encoded_buf[*current_idx..]);
+        encoded_buf[*current_idx] = 0;
+        *current_idx += 1;
+    }
+
+    #[test]
+    fn test_parsing_simple_packet() {
+        let mut test_sender = TcCacher::default();
+        let mut encoded_buf: [u8; 16] = [0; 16];
+        let mut current_idx = 0;
+        encode_simple_packet(&mut encoded_buf, &mut current_idx);
+        let mut next_read_idx = 0;
+        let packets = parse_buffer_for_cobs_encoded_packets(
+            &mut encoded_buf[0..current_idx],
+            &mut test_sender,
+            &mut next_read_idx,
+        )
+        .unwrap();
+        assert_eq!(packets, 1);
+        assert_eq!(test_sender.tc_queue.len(), 1);
+        let packet = &test_sender.tc_queue[0];
+        assert_eq!(packet, &SIMPLE_PACKET);
+    }
+
+    #[test]
+    fn test_parsing_consecutive_packets() {
+        let mut test_sender = TcCacher::default();
+        let mut encoded_buf: [u8; 16] = [0; 16];
+        let mut current_idx = 0;
+        encode_simple_packet(&mut encoded_buf, &mut current_idx);
+
+        // Second packet
+        encoded_buf[current_idx] = 0;
+        current_idx += 1;
+        current_idx += encode(&INVERTED_PACKET, &mut encoded_buf[current_idx..]);
+        encoded_buf[current_idx] = 0;
+        current_idx += 1;
+        let mut next_read_idx = 0;
+        let packets = parse_buffer_for_cobs_encoded_packets(
+            &mut encoded_buf[0..current_idx],
+            &mut test_sender,
+            &mut next_read_idx,
+        )
+        .unwrap();
+        assert_eq!(packets, 2);
+        assert_eq!(test_sender.tc_queue.len(), 2);
+        let packet0 = &test_sender.tc_queue[0];
+        assert_eq!(packet0, &SIMPLE_PACKET);
+        let packet1 = &test_sender.tc_queue[1];
+        assert_eq!(packet1, &INVERTED_PACKET);
+    }
+
+    #[test]
+    fn test_split_tail_packet_only() {
+        let mut test_sender = TcCacher::default();
+        let mut encoded_buf: [u8; 16] = [0; 16];
+        let mut current_idx = 0;
+        encode_simple_packet(&mut encoded_buf, &mut current_idx);
+        let mut next_read_idx = 0;
+        let packets = parse_buffer_for_cobs_encoded_packets(
+            // Cut off the sentinel byte at the end.
+            &mut encoded_buf[0..current_idx - 1],
+            &mut test_sender,
+            &mut next_read_idx,
+        )
+        .unwrap();
+        assert_eq!(packets, 0);
+        assert_eq!(test_sender.tc_queue.len(), 0);
+        assert_eq!(next_read_idx, 0);
+    }
+
+    fn generic_test_split_packet(cut_off: usize) {
+        let mut test_sender = TcCacher::default();
+        let mut encoded_buf: [u8; 16] = [0; 16];
+        assert!(cut_off < INVERTED_PACKET.len() + 1);
+        let mut current_idx = 0;
+        encode_simple_packet(&mut encoded_buf, &mut current_idx);
+        // Second packet
+        encoded_buf[current_idx] = 0;
+        let packet_start = current_idx;
+        current_idx += 1;
+        let encoded_len = encode(&INVERTED_PACKET, &mut encoded_buf[current_idx..]);
+        assert_eq!(encoded_len, 6);
+        current_idx += encoded_len;
+        // We cut off the sentinel byte, so we expecte the write index to be the length of the
+        // packet minus the sentinel byte plus the first sentinel byte.
+        let next_expected_write_idx = 1 + encoded_len - cut_off + 1;
+        encoded_buf[current_idx] = 0;
+        current_idx += 1;
+        let mut next_write_idx = 0;
+        let expected_at_start = encoded_buf[packet_start..current_idx - cut_off].to_vec();
+        let packets = parse_buffer_for_cobs_encoded_packets(
+            // Cut off the sentinel byte at the end.
+            &mut encoded_buf[0..current_idx - cut_off],
+            &mut test_sender,
+            &mut next_write_idx,
+        )
+        .unwrap();
+        assert_eq!(packets, 1);
+        assert_eq!(test_sender.tc_queue.len(), 1);
+        assert_eq!(&test_sender.tc_queue[0], &SIMPLE_PACKET);
+        assert_eq!(next_write_idx, next_expected_write_idx);
+        assert_eq!(encoded_buf[..next_expected_write_idx], expected_at_start);
+    }
+
+    #[test]
+    fn test_one_packet_and_split_tail_packet_0() {
+        generic_test_split_packet(1);
+    }
+
+    #[test]
+    fn test_one_packet_and_split_tail_packet_1() {
+        generic_test_split_packet(2);
+    }
+
+    #[test]
+    fn test_one_packet_and_split_tail_packet_2() {
+        generic_test_split_packet(3);
+    }
+
+    #[test]
+    fn test_zero_at_end() {
+        let mut test_sender = TcCacher::default();
+        let mut encoded_buf: [u8; 16] = [0; 16];
+        let mut next_write_idx = 0;
+        let mut current_idx = 0;
+        encoded_buf[current_idx] = 5;
+        current_idx += 1;
+        encode_simple_packet(&mut encoded_buf, &mut current_idx);
+        encoded_buf[current_idx] = 0;
+        current_idx += 1;
+        let packets = parse_buffer_for_cobs_encoded_packets(
+            // Cut off the sentinel byte at the end.
+            &mut encoded_buf[0..current_idx],
+            &mut test_sender,
+            &mut next_write_idx,
+        )
+        .unwrap();
+        assert_eq!(packets, 1);
+        assert_eq!(test_sender.tc_queue.len(), 1);
+        assert_eq!(&test_sender.tc_queue[0], &SIMPLE_PACKET);
+        assert_eq!(next_write_idx, 1);
+        assert_eq!(encoded_buf[0], 0);
+    }
+
+    #[test]
+    fn test_all_zeroes() {
+        let mut test_sender = TcCacher::default();
+        let mut all_zeroes: [u8; 5] = [0; 5];
+        let mut next_write_idx = 0;
+        let packets = parse_buffer_for_cobs_encoded_packets(
+            // Cut off the sentinel byte at the end.
+            &mut all_zeroes,
+            &mut test_sender,
+            &mut next_write_idx,
+        )
+        .unwrap();
+        assert_eq!(packets, 0);
+        assert!(test_sender.tc_queue.is_empty());
+        assert_eq!(next_write_idx, 0);
+    }
+}