Classify timeouts as ProtocolViolation and add test

This now ignores timeouts.

src/command/error.rs

@@ -24,11 +24,11 @@ impl From<subprocess::PopenError> for CommandError {
 impl From<CommunicationError> for CommandError {
     fn from(e: CommunicationError) -> Self {
         match e {
-            CommunicationError::PacketInvalidError => CommandError::External(Box::new(e)),
-            CommunicationError::CepParsing(_) => CommandError::ProtocolViolation(Box::new(e)),
-            CommunicationError::Io(_) => CommandError::NonRecoverable(Box::new(e)),
-            CommunicationError::NotAcknowledged => CommandError::ProtocolViolation(Box::new(e)),
-            CommunicationError::TimedOut => todo!("Timeout not yet specified"),
+            CommunicationError::PacketInvalidError => CommandError::External(e.into()),
+            CommunicationError::CepParsing(_) => CommandError::ProtocolViolation(e.into()),
+            CommunicationError::Io(_) => CommandError::NonRecoverable(e.into()),
+            CommunicationError::NotAcknowledged => CommandError::ProtocolViolation(e.into()),
+            CommunicationError::TimedOut => CommandError::ProtocolViolation(e.into()),
         }
     }
 }

src/communication/mod.rs

@@ -123,7 +123,7 @@ pub trait CommunicationHandle: Read + Write {
 }
 
 impl CommunicationHandle for Box<dyn serialport::SerialPort> {
-    const INTEGRITY_ACK_TIMEOUT: Duration = Duration::from_millis(100);
+    const INTEGRITY_ACK_TIMEOUT: Duration = Duration::from_millis(1000);
     /// Equivalent to 106 days, maximum allowed value due to library limitations (of all serialport libraries I found)
     const UNLIMITED_TIMEOUT: Duration = Duration::from_millis(9223372035);
 
@@ -165,7 +165,7 @@ impl From<std::io::Error> for CommunicationError {
 impl From<CEPParseError> for CommunicationError {
     fn from(value: CEPParseError) -> Self {
         match value {
-            CEPParseError::Io(e) => Self::Io(e),
+            CEPParseError::Io(e) => e.into(),
             e => Self::CepParsing(e),
         }
     }

tests/simulation/mod.rs

@@ -1,6 +1,7 @@
 mod command_execution;
 mod full_run;
 mod logging;
+mod timeout;
 
 use std::{
     io::{Read, Write},

tests/simulation/timeout.rs

@@ -0,0 +1,22 @@
+use std::time::Duration;
+use STS1_EDU_Scheduler::communication::{CommunicationHandle, CEPPacket};
+use super::{SimulationComHandle, start_scheduler, get_status};
+
+#[test]
+fn integrity_ack_timeout_is_honored() {
+    let (mut cobc, _socat) = SimulationComHandle::with_socat_proc("integrity_timeout");
+    let _sched = start_scheduler("integrity_timeout").unwrap();
+
+    // Check that delayed ACK is allowed
+    cobc.send_packet(&CEPPacket::Data(get_status())).unwrap();
+    std::thread::sleep(Duration::from_millis(500));
+    assert_eq!(cobc.receive_packet().unwrap(), CEPPacket::Data(vec![0]));
+
+    cobc.send_packet(&CEPPacket::Data(get_status())).unwrap();
+    assert_eq!(CEPPacket::try_from_read(&mut cobc.cobc_in).unwrap(), CEPPacket::Data(vec![0])); // No ACK sent!
+    std::thread::sleep(Duration::from_millis(1010));
+
+    // Timeout passed, normal communication should be possible
+    cobc.send_packet(&CEPPacket::Data(get_status())).unwrap();
+    assert_eq!(cobc.receive_packet().unwrap(), CEPPacket::Data(vec![0]));
+}