chore: M5 CI/Workflow Sweep - final synchronisation

Author: hyperpolymath

src/abi/mod.rs

@@ -556,17 +556,17 @@ mod tests {
     #[test]
     fn test_clock_creation() {
         assert!(Clock::new(0).is_none());
-        let clk = Clock::new(10).unwrap();
+        let clk = Clock::new(10).expect("TODO: handle error");
         assert_eq!(clk.base_period_ms, 10);
         assert!((clk.frequency_hz() - 100.0).abs() < 0.001);
     }
 
     #[test]
     fn test_signal_type_parsing() {
-        assert_eq!("bool".parse::<SignalType>().unwrap(), SignalType::Bool);
-        assert_eq!("int".parse::<SignalType>().unwrap(), SignalType::Int);
-        assert_eq!("float".parse::<SignalType>().unwrap(), SignalType::Float);
-        assert_eq!("real".parse::<SignalType>().unwrap(), SignalType::Real);
+        assert_eq!("bool".parse::<SignalType>().expect("TODO: handle error"), SignalType::Bool);
+        assert_eq!("int".parse::<SignalType>().expect("TODO: handle error"), SignalType::Int);
+        assert_eq!("float".parse::<SignalType>().expect("TODO: handle error"), SignalType::Float);
+        assert_eq!("real".parse::<SignalType>().expect("TODO: handle error"), SignalType::Real);
         assert!("unknown".parse::<SignalType>().is_err());
     }
 
@@ -580,7 +580,7 @@ mod tests {
 
     #[test]
     fn test_node_validation() {
-        let clk = Clock::new(10).unwrap();
+        let clk = Clock::new(10).expect("TODO: handle error");
         let mut node = LustreNode::new("test", clk);
         let errors = node.validate();
         assert!(errors.iter().any(|e| e.contains("at least one input")));
@@ -598,31 +598,31 @@ mod tests {
     #[test]
     fn test_safety_standard_parsing() {
         assert_eq!(
-            "DO-178C".parse::<SafetyStandard>().unwrap(),
+            "DO-178C".parse::<SafetyStandard>().expect("TODO: handle error"),
             SafetyStandard::Do178c
         );
         assert_eq!(
-            "IEC-61508".parse::<SafetyStandard>().unwrap(),
+            "IEC-61508".parse::<SafetyStandard>().expect("TODO: handle error"),
             SafetyStandard::Iec61508
         );
         assert_eq!(
-            "ISO-26262".parse::<SafetyStandard>().unwrap(),
+            "ISO-26262".parse::<SafetyStandard>().expect("TODO: handle error"),
             SafetyStandard::Iso26262
         );
     }
 
     #[test]
     fn test_embedded_target_parsing() {
         assert_eq!(
-            "arm-cortex-m".parse::<EmbeddedTarget>().unwrap(),
+            "arm-cortex-m".parse::<EmbeddedTarget>().expect("TODO: handle error"),
             EmbeddedTarget::ArmCortexM
         );
         assert_eq!(
-            "riscv".parse::<EmbeddedTarget>().unwrap(),
+            "riscv".parse::<EmbeddedTarget>().expect("TODO: handle error"),
             EmbeddedTarget::RiscV
         );
         assert_eq!(
-            "x86".parse::<EmbeddedTarget>().unwrap(),
+            "x86".parse::<EmbeddedTarget>().expect("TODO: handle error"),
             EmbeddedTarget::X86
         );
     }

src/codegen/c_gen.rs

@@ -334,7 +334,7 @@ mod tests {
             name: "ctrl".to_string(),
             inputs: vec![Signal::new("x", SignalType::Real)],
             outputs: vec![Signal::new("y", SignalType::Real)],
-            clock: Clock::new(10).unwrap(),
+            clock: Clock::new(10).expect("TODO: handle error"),
             operator_count: 1,
             is_multi_rate: false,
         }
@@ -406,7 +406,7 @@ mod tests {
                 Signal::new("out_fast", SignalType::Real),
                 Signal::new("out_slow", SignalType::Real),
             ],
-            clock: Clock::new(10).unwrap(),
+            clock: Clock::new(10).expect("TODO: handle error"),
             operator_count: 3,
             is_multi_rate: true,
         };
@@ -422,7 +422,7 @@ mod tests {
             name: "latch".to_string(),
             inputs: vec![Signal::new("trigger", SignalType::Bool)],
             outputs: vec![Signal::new("held", SignalType::Bool)],
-            clock: Clock::new(1).unwrap(),
+            clock: Clock::new(1).expect("TODO: handle error"),
             operator_count: 1,
             is_multi_rate: false,
         };

src/codegen/lustre_gen.rs

@@ -261,7 +261,7 @@ mod tests {
             name: "integrator".to_string(),
             inputs: vec![Signal::new("x", SignalType::Real)],
             outputs: vec![Signal::new("y", SignalType::Real)],
-            clock: Clock::new(10).unwrap(),
+            clock: Clock::new(10).expect("TODO: handle error"),
             operator_count: 1,
             is_multi_rate: false,
         }
@@ -301,7 +301,7 @@ mod tests {
                 Signal::new("out_slow", SignalType::Real),
                 Signal::new("out_fast", SignalType::Real),
             ],
-            clock: Clock::new(5).unwrap(),
+            clock: Clock::new(5).expect("TODO: handle error"),
             operator_count: 3,
             is_multi_rate: true,
         };
@@ -339,7 +339,7 @@ mod tests {
             name: "latch".to_string(),
             inputs: vec![Signal::new("trigger", SignalType::Bool)],
             outputs: vec![Signal::new("held", SignalType::Bool)],
-            clock: Clock::new(1).unwrap(),
+            clock: Clock::new(1).expect("TODO: handle error"),
             operator_count: 1,
             is_multi_rate: false,
         };

src/codegen/parser.rs

@@ -149,7 +149,7 @@ mod tests {
     #[test]
     fn test_parse_single_rate_node() {
         let m = minimal_manifest(vec!["x:int"], vec!["y:int"]);
-        let nodes = parse_nodes(&m).unwrap();
+        let nodes = parse_nodes(&m).expect("TODO: handle error");
         assert_eq!(nodes.len(), 1);
         assert_eq!(nodes[0].name, "ctrl");
         assert_eq!(nodes[0].inputs.len(), 1);
@@ -162,7 +162,7 @@ mod tests {
     #[test]
     fn test_parse_multi_rate_node() {
         let m = minimal_manifest(vec!["fast:real", "slow:real@10"], vec!["out:real"]);
-        let nodes = parse_nodes(&m).unwrap();
+        let nodes = parse_nodes(&m).expect("TODO: handle error");
         assert!(nodes[0].is_multi_rate);
         assert_eq!(nodes[0].inputs[1].rate, 10);
         assert!(nodes[0].operator_count > 0);
@@ -207,7 +207,7 @@ mod tests {
             data: None,
             options: None,
         };
-        let nodes = parse_nodes(&m).unwrap();
+        let nodes = parse_nodes(&m).expect("TODO: handle error");
         assert_eq!(nodes.len(), 2);
         assert_eq!(nodes[0].name, "sensor");
         assert_eq!(nodes[1].name, "actuator");

src/manifest/mod.rs

@@ -260,7 +260,7 @@ pub fn validate(manifest: &Manifest) -> Result<()> {
         if node.name.is_empty() {
             anyhow::bail!("{}: name must not be empty", ctx);
         }
-        if !node.name.chars().next().unwrap().is_ascii_alphabetic() && !node.name.starts_with('_') {
+        if !node.name.chars().next().expect("TODO: handle error").is_ascii_alphabetic() && !node.name.starts_with('_') {
             anyhow::bail!("{}: name must start with a letter or underscore", ctx);
         }
 
@@ -392,23 +392,23 @@ mod tests {
 
     #[test]
     fn test_parse_signal_basic() {
-        let s = parse_signal("pitch:real").unwrap();
+        let s = parse_signal("pitch:real").expect("TODO: handle error");
         assert_eq!(s.name, "pitch");
         assert_eq!(s.signal_type, "real");
         assert_eq!(s.rate, 1);
     }
 
     #[test]
     fn test_parse_signal_with_rate() {
-        let s = parse_signal("gps_lat:real@10").unwrap();
+        let s = parse_signal("gps_lat:real@10").expect("TODO: handle error");
         assert_eq!(s.name, "gps_lat");
         assert_eq!(s.signal_type, "real");
         assert_eq!(s.rate, 10);
     }
 
     #[test]
     fn test_parse_signal_trimming() {
-        let s = parse_signal("  temp : float @ 5 ").unwrap();
+        let s = parse_signal("  temp : float @ 5 ").expect("TODO: handle error");
         assert_eq!(s.name, "temp");
         assert_eq!(s.signal_type, "float");
         assert_eq!(s.rate, 5);