Lots + MIDI implementation

tests/forth/harness.rs

@@ -18,6 +18,7 @@ pub fn default_ctx() -> StepContext {
         speed: 1.0,
         fill: false,
         nudge_secs: 0.0,
+        cc_memory: None,
     }
 }
 

tests/forth/midi.rs

@@ -0,0 +1,284 @@
+use crate::harness::{default_ctx, expect_outputs, forth};
+use cagire::forth::{CcMemory, StepContext};
+use std::sync::{Arc, Mutex};
+
+#[test]
+fn test_midi_channel_set() {
+    let outputs = expect_outputs("60 note 100 velocity 3 chan m.", 1);
+    assert!(outputs[0].starts_with("/midi/note/60/vel/100/chan/2/dur/"));
+}
+
+#[test]
+fn test_midi_note_default_channel() {
+    let outputs = expect_outputs("72 note 80 velocity m.", 1);
+    assert!(outputs[0].starts_with("/midi/note/72/vel/80/chan/0/dur/"));
+}
+
+#[test]
+fn test_midi_cc() {
+    let outputs = expect_outputs("64 ccnum 127 ccout m.", 1);
+    assert!(outputs[0].contains("/midi/cc/64/127/chan/0"));
+}
+
+#[test]
+fn test_midi_cc_with_channel() {
+    let outputs = expect_outputs("5 chan 1 ccnum 64 ccout m.", 1);
+    assert!(outputs[0].contains("/midi/cc/1/64/chan/4"));
+}
+
+#[test]
+fn test_ccval_returns_zero_without_cc_memory() {
+    let f = forth();
+    let ctx = default_ctx();
+    let outputs = f.evaluate("1 1 ccval", &ctx).unwrap();
+    assert!(outputs.is_empty());
+    let stack = f.stack();
+    assert_eq!(stack.len(), 1);
+    match &stack[0] {
+        cagire::forth::Value::Int(v, _) => assert_eq!(*v, 0),
+        _ => panic!("expected Int"),
+    }
+}
+
+#[test]
+fn test_ccval_reads_from_cc_memory() {
+    let cc_memory: CcMemory = Arc::new(Mutex::new([[0u8; 128]; 16]));
+    {
+        let mut mem = cc_memory.lock().unwrap();
+        mem[0][1] = 64; // channel 1 (0-indexed), CC 1, value 64
+        mem[5][74] = 127; // channel 6 (0-indexed), CC 74, value 127
+    }
+
+    let f = forth();
+    let ctx = StepContext {
+        cc_memory: Some(Arc::clone(&cc_memory)),
+        ..default_ctx()
+    };
+
+    // Test CC 1 on channel 1 (user provides 1, internally 0)
+    f.evaluate("1 1 ccval", &ctx).unwrap();
+    let stack = f.stack();
+    assert_eq!(stack.len(), 1);
+    match &stack[0] {
+        cagire::forth::Value::Int(v, _) => assert_eq!(*v, 64),
+        _ => panic!("expected Int"),
+    }
+    f.clear_stack();
+
+    // Test CC 74 on channel 6 (user provides 6, internally 5)
+    f.evaluate("74 6 ccval", &ctx).unwrap();
+    let stack = f.stack();
+    assert_eq!(stack.len(), 1);
+    match &stack[0] {
+        cagire::forth::Value::Int(v, _) => assert_eq!(*v, 127),
+        _ => panic!("expected Int"),
+    }
+}
+
+#[test]
+fn test_midi_channel_clamping() {
+    // Channel should be clamped 1-16, then converted to 0-15 internally
+    let outputs = expect_outputs("60 note 100 velocity 0 chan m.", 1);
+    assert!(outputs[0].contains("/chan/0")); // 0 clamped to 1, then -1 = 0
+
+    let outputs = expect_outputs("60 note 100 velocity 17 chan m.", 1);
+    assert!(outputs[0].contains("/chan/15")); // 17 clamped to 16, then -1 = 15
+}
+
+#[test]
+fn test_midi_note_clamping() {
+    let outputs = expect_outputs("-1 note 100 velocity m.", 1);
+    assert!(outputs[0].contains("/note/0"));
+
+    let outputs = expect_outputs("200 note 100 velocity m.", 1);
+    assert!(outputs[0].contains("/note/127"));
+}
+
+#[test]
+fn test_midi_velocity_clamping() {
+    let outputs = expect_outputs("60 note -10 velocity m.", 1);
+    assert!(outputs[0].contains("/vel/0"));
+
+    let outputs = expect_outputs("60 note 200 velocity m.", 1);
+    assert!(outputs[0].contains("/vel/127"));
+}
+
+#[test]
+fn test_midi_defaults() {
+    // With only note specified, velocity defaults to 100 and channel to 0
+    let outputs = expect_outputs("60 note m.", 1);
+    assert!(outputs[0].starts_with("/midi/note/60/vel/100/chan/0/dur/"));
+}
+
+#[test]
+fn test_midi_full_defaults() {
+    // With nothing specified, defaults to note=60, velocity=100, channel=0
+    let outputs = expect_outputs("m.", 1);
+    assert!(outputs[0].starts_with("/midi/note/60/vel/100/chan/0/dur/"));
+}
+
+// Pitch bend tests
+#[test]
+fn test_midi_bend_center() {
+    let outputs = expect_outputs("0.0 bend m.", 1);
+    // 0.0 -> 8192 (center)
+    assert!(outputs[0].contains("/midi/bend/8191/chan/0") || outputs[0].contains("/midi/bend/8192/chan/0"));
+}
+
+#[test]
+fn test_midi_bend_max() {
+    let outputs = expect_outputs("1.0 bend m.", 1);
+    // 1.0 -> 16383 (max)
+    assert!(outputs[0].contains("/midi/bend/16383/chan/0"));
+}
+
+#[test]
+fn test_midi_bend_min() {
+    let outputs = expect_outputs("-1.0 bend m.", 1);
+    // -1.0 -> 0 (min)
+    assert!(outputs[0].contains("/midi/bend/0/chan/0"));
+}
+
+#[test]
+fn test_midi_bend_with_channel() {
+    let outputs = expect_outputs("0.5 bend 3 chan m.", 1);
+    assert!(outputs[0].contains("/chan/2")); // channel 3 -> 2 (0-indexed)
+    assert!(outputs[0].contains("/midi/bend/"));
+}
+
+#[test]
+fn test_midi_bend_clamping() {
+    let outputs = expect_outputs("2.0 bend m.", 1);
+    // 2.0 clamped to 1.0 -> 16383
+    assert!(outputs[0].contains("/midi/bend/16383/chan/0"));
+
+    let outputs = expect_outputs("-5.0 bend m.", 1);
+    // -5.0 clamped to -1.0 -> 0
+    assert!(outputs[0].contains("/midi/bend/0/chan/0"));
+}
+
+// Channel pressure (aftertouch) tests
+#[test]
+fn test_midi_pressure() {
+    let outputs = expect_outputs("64 pressure m.", 1);
+    assert!(outputs[0].contains("/midi/pressure/64/chan/0"));
+}
+
+#[test]
+fn test_midi_pressure_with_channel() {
+    let outputs = expect_outputs("100 pressure 5 chan m.", 1);
+    assert!(outputs[0].contains("/midi/pressure/100/chan/4"));
+}
+
+#[test]
+fn test_midi_pressure_clamping() {
+    let outputs = expect_outputs("-10 pressure m.", 1);
+    assert!(outputs[0].contains("/midi/pressure/0/chan/0"));
+
+    let outputs = expect_outputs("200 pressure m.", 1);
+    assert!(outputs[0].contains("/midi/pressure/127/chan/0"));
+}
+
+// Program change tests
+#[test]
+fn test_midi_program() {
+    let outputs = expect_outputs("0 program m.", 1);
+    assert!(outputs[0].contains("/midi/program/0/chan/0"));
+}
+
+#[test]
+fn test_midi_program_with_channel() {
+    let outputs = expect_outputs("42 program 10 chan m.", 1);
+    assert!(outputs[0].contains("/midi/program/42/chan/9"));
+}
+
+#[test]
+fn test_midi_program_clamping() {
+    let outputs = expect_outputs("-1 program m.", 1);
+    assert!(outputs[0].contains("/midi/program/0/chan/0"));
+
+    let outputs = expect_outputs("200 program m.", 1);
+    assert!(outputs[0].contains("/midi/program/127/chan/0"));
+}
+
+// MIDI real-time messages
+#[test]
+fn test_midi_clock() {
+    let outputs = expect_outputs("mclock", 1);
+    assert_eq!(outputs[0], "/midi/clock");
+}
+
+#[test]
+fn test_midi_start() {
+    let outputs = expect_outputs("mstart", 1);
+    assert_eq!(outputs[0], "/midi/start");
+}
+
+#[test]
+fn test_midi_stop() {
+    let outputs = expect_outputs("mstop", 1);
+    assert_eq!(outputs[0], "/midi/stop");
+}
+
+#[test]
+fn test_midi_continue() {
+    let outputs = expect_outputs("mcont", 1);
+    assert_eq!(outputs[0], "/midi/continue");
+}
+
+// Test message type priority (first matching type wins)
+#[test]
+fn test_midi_message_priority_cc_over_note() {
+    // CC params take priority over note
+    let outputs = expect_outputs("60 note 1 ccnum 64 ccout m.", 1);
+    assert!(outputs[0].contains("/midi/cc/1/64"));
+}
+
+#[test]
+fn test_midi_message_priority_bend_over_note() {
+    // bend takes priority over note (but not over CC)
+    let outputs = expect_outputs("60 note 0.5 bend m.", 1);
+    assert!(outputs[0].contains("/midi/bend/"));
+}
+
+// MIDI note duration tests
+#[test]
+fn test_midi_note_default_duration() {
+    // Default dur=1.0, with tempo=120 and speed=1.0, step_duration = 60/120/4/1 = 0.125
+    let outputs = expect_outputs("60 note m.", 1);
+    assert!(outputs[0].contains("/dur/0.125"));
+}
+
+#[test]
+fn test_midi_note_explicit_duration() {
+    // dur=0.5 means half step duration = 0.0625 seconds
+    let outputs = expect_outputs("60 note 0.5 dur m.", 1);
+    assert!(outputs[0].contains("/dur/0.0625"));
+}
+
+#[test]
+fn test_midi_note_long_duration() {
+    // dur=2.0 means two step durations = 0.25 seconds
+    let outputs = expect_outputs("60 note 2 dur m.", 1);
+    assert!(outputs[0].contains("/dur/0.25"));
+}
+
+#[test]
+fn test_midi_note_duration_with_tempo() {
+    use crate::harness::{ctx_with, forth};
+    let f = forth();
+    // At tempo=60, step_duration = 60/60/4/1 = 0.25 seconds
+    let ctx = ctx_with(|c| c.tempo = 60.0);
+    let outputs = f.evaluate("60 note m.", &ctx).unwrap();
+    assert!(outputs[0].contains("/dur/0.25"));
+}
+
+#[test]
+fn test_midi_note_duration_with_speed() {
+    use crate::harness::{ctx_with, forth};
+    let f = forth();
+    // At tempo=120 speed=2, step_duration = 60/120/4/2 = 0.0625 seconds
+    let ctx = ctx_with(|c| c.speed = 2.0);
+    let outputs = f.evaluate("60 note m.", &ctx).unwrap();
+    assert!(outputs[0].contains("/dur/0.0625"));
+}