BuboBubo/Cagire
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Cleaning old temporal model

Browse Source
This commit is contained in:
Raphaël Forment
2026-01-29 01:28:57 +01:00
parent 48f5920fed
commit 8efafffaff
5 changed files with 65 additions and 589 deletions
Download Patch File Download Diff File Expand all files Collapse all files

240
tests/forth/temporal.rs
View File

@@ -48,9 +48,6 @@ fn approx_eq(a: f64, b: f64) -> bool {
(a - b).abs() < EPSILON
}
// At 120 BPM, speed 1.0: stepdur = 60/120/4/1 = 0.125s
// Root duration = 4 * stepdur = 0.5s
#[test]
fn stepdur_baseline() {
let f = run("stepdur");
@@ -65,72 +62,14 @@ fn single_emit() {
}
#[test]
fn implicit_subdivision_2() {
let outputs = expect_outputs(r#""kick" s . ."#, 2);
let deltas = get_deltas(&outputs);
let step = 0.5 / 2.0;
assert!(approx_eq(deltas[0], 0.0), "first slot at 0");
assert!(approx_eq(deltas[1], step), "second slot at {}, got {}", step, deltas[1]);
}
#[test]
fn implicit_subdivision_4() {
fn multiple_emits_all_at_zero() {
let outputs = expect_outputs(r#""kick" s . . . ."#, 4);
let deltas = get_deltas(&outputs);
let step = 0.5 / 4.0;
for (i, delta) in deltas.iter().enumerate() {
let expected = step * i as f64;
assert!(
approx_eq(*delta, expected),
"slot {}: expected {}, got {}",
i, expected, delta
);
assert!(approx_eq(*delta, 0.0), "emit {}: expected delta 0, got {}", i, delta);
}
}
#[test]
fn implicit_subdivision_3() {
let outputs = expect_outputs(r#""kick" s . . ."#, 3);
let deltas = get_deltas(&outputs);
let step = 0.5 / 3.0;
assert!(approx_eq(deltas[0], 0.0));
assert!(approx_eq(deltas[1], step), "got {}", deltas[1]);
assert!(approx_eq(deltas[2], 2.0 * step), "got {}", deltas[2]);
}
#[test]
fn silence_creates_gap() {
let outputs = expect_outputs(r#""kick" s . _ ."#, 2);
let deltas = get_deltas(&outputs);
let step = 0.5 / 3.0;
assert!(approx_eq(deltas[0], 0.0), "first at 0");
assert!(
approx_eq(deltas[1], 2.0 * step),
"third slot (after silence) at {}, got {}",
2.0 * step,
deltas[1]
);
}
#[test]
fn silence_at_start() {
let outputs = expect_outputs(r#""kick" s _ ."#, 1);
let deltas = get_deltas(&outputs);
let step = 0.5 / 2.0;
assert!(
approx_eq(deltas[0], step),
"emit after silence at {}, got {}",
step,
deltas[0]
);
}
#[test]
fn silence_only() {
let outputs = expect_outputs(r#""kick" s _"#, 0);
assert!(outputs.is_empty(), "silence only should produce no output");
}
#[test]
fn sound_persists() {
let outputs = expect_outputs(r#""kick" s . . "hat" s . ."#, 4);
@@ -149,41 +88,10 @@ fn alternating_sounds() {
}
#[test]
fn dur_matches_slot_duration() {
let outputs = expect_outputs(r#""kick" s . . . ."#, 4);
fn dur_is_step_duration() {
let outputs = expect_outputs(r#""kick" s ."#, 1);
let durs = get_durs(&outputs);
let expected_dur = 0.5 / 4.0;
for (i, dur) in durs.iter().enumerate() {
assert!(
approx_eq(*dur, expected_dur),
"slot {} dur: expected {}, got {}",
i, expected_dur, dur
);
}
}
#[test]
fn tempo_affects_subdivision() {
let ctx = ctx_with(|c| c.tempo = 60.0);
let f = forth();
let outputs = f.evaluate(r#""kick" s . ."#, &ctx).unwrap();
let deltas = get_deltas(&outputs);
// At 60 BPM: stepdur = 0.25, root dur = 1.0
let step = 1.0 / 2.0;
assert!(approx_eq(deltas[0], 0.0));
assert!(approx_eq(deltas[1], step), "got {}", deltas[1]);
}
#[test]
fn speed_affects_subdivision() {
let ctx = ctx_with(|c| c.speed = 2.0);
let f = forth();
let outputs = f.evaluate(r#""kick" s . ."#, &ctx).unwrap();
let deltas = get_deltas(&outputs);
// At speed 2.0: stepdur = 0.0625, root dur = 0.25
let step = 0.25 / 2.0;
assert!(approx_eq(deltas[0], 0.0));
assert!(approx_eq(deltas[1], step), "got {}", deltas[1]);
assert!(approx_eq(durs[0], 0.125), "dur should be step_duration (0.125), got {}", durs[0]);
}
#[test]
@@ -227,143 +135,6 @@ fn cycle_with_sounds() {
}
}
#[test]
fn dot_alias_for_emit() {
let outputs = expect_outputs(r#""kick" s . . . ."#, 4);
let sounds = get_sounds(&outputs);
assert_eq!(sounds, vec!["kick", "kick", "kick", "kick"]);
}
#[test]
fn dot_with_silence() {
let outputs = expect_outputs(r#""kick" s . _ . _"#, 2);
let deltas = get_deltas(&outputs);
let step = 0.5 / 4.0;
assert!(approx_eq(deltas[0], 0.0));
assert!(approx_eq(deltas[1], 2.0 * step));
}
#[test]
fn div_basic_subdivision() {
let outputs = expect_outputs(r#"div "kick" s . "hat" s . ~"#, 2);
let deltas = get_deltas(&outputs);
let sounds = get_sounds(&outputs);
assert_eq!(sounds, vec!["kick", "hat"]);
assert!(approx_eq(deltas[0], 0.0));
assert!(approx_eq(deltas[1], 0.25), "second should be at 0.25, got {}", deltas[1]);
}
#[test]
fn div_sequential() {
// Two consecutive divs each claim a slot in root, so they're sequential
let outputs = expect_outputs(r#"div "kick" s . ~ div "hat" s . ~"#, 2);
let deltas = get_deltas(&outputs);
let sounds = get_sounds(&outputs);
assert_eq!(sounds, vec!["kick", "hat"]);
assert!(approx_eq(deltas[0], 0.0));
assert!(approx_eq(deltas[1], 0.25), "second div at slot 1, got {}", deltas[1]);
}
#[test]
fn div_with_root_emit() {
// kick claims slot 0 at root, div claims slot 1 at root
let outputs = expect_outputs(r#""kick" s . div "hat" s . ~"#, 2);
let deltas = get_deltas(&outputs);
let sounds = get_sounds(&outputs);
assert_eq!(sounds, vec!["kick", "hat"]);
assert!(approx_eq(deltas[0], 0.0), "kick at slot 0");
assert!(approx_eq(deltas[1], 0.25), "hat at slot 1, got {}", deltas[1]);
}
#[test]
fn div_nested() {
// kick claims slot 0 in outer div, inner div claims slot 1
// Inner div's 2 hats subdivide its slot (0.25 duration) into 2 sub-slots
let outputs = expect_outputs(r#"div "kick" s . div "hat" s . . ~ ~"#, 3);
let sounds = get_sounds(&outputs);
let deltas = get_deltas(&outputs);
// Output order: kick (slot 0), then hats (slot 1 subdivided)
assert_eq!(sounds[0], "kick");
assert_eq!(sounds[1], "hat");
assert_eq!(sounds[2], "hat");
// Outer div has 2 slots of 0.25 each
// kick at slot 0 -> delta 0
// inner div at slot 1 -> starts at 0.25, subdivided into 2 -> hats at 0.25 and 0.375
assert!(approx_eq(deltas[0], 0.0), "kick at 0, got {}", deltas[0]);
assert!(approx_eq(deltas[1], 0.25), "first hat at 0.25, got {}", deltas[1]);
assert!(approx_eq(deltas[2], 0.375), "second hat at 0.375, got {}", deltas[2]);
}
#[test]
fn div_with_silence() {
let outputs = expect_outputs(r#"div "kick" s . _ ~"#, 1);
let deltas = get_deltas(&outputs);
assert!(approx_eq(deltas[0], 0.0));
}
#[test]
fn unmatched_scope_terminator_error() {
let f = forth();
let result = f.evaluate(r#""kick" s . ~"#, &default_ctx());
assert!(result.is_err(), "unmatched ~ should error");
}
#[test]
fn stack_superposes_sounds() {
let outputs = expect_outputs(r#"stack "kick" s . "hat" s . ~"#, 2);
let deltas = get_deltas(&outputs);
let sounds = get_sounds(&outputs);
assert_eq!(sounds.len(), 2);
// Both at delta 0 (stacked/superposed)
assert!(approx_eq(deltas[0], 0.0));
assert!(approx_eq(deltas[1], 0.0));
}
#[test]
fn stack_with_multiple_emits() {
let outputs = expect_outputs(r#"stack "kick" s . . . . ~"#, 4);
let deltas = get_deltas(&outputs);
// All 4 kicks at delta 0
for (i, delta) in deltas.iter().enumerate() {
assert!(approx_eq(*delta, 0.0), "emit {} should be at 0, got {}", i, delta);
}
}
#[test]
fn stack_inside_div() {
// div subdivides, stack inside superposes
// stack doesn't claim a slot in parent div, so snare is also at 0
let outputs = expect_outputs(r#"div stack "kick" s . "hat" s . ~ "snare" s . ~"#, 3);
let deltas = get_deltas(&outputs);
let sounds = get_sounds(&outputs);
// stack resolves first (kick, hat at 0), then div resolves (snare at 0)
// since stack doesn't consume a slot in the parent div
assert_eq!(sounds[0], "kick");
assert_eq!(sounds[1], "hat");
assert_eq!(sounds[2], "snare");
assert!(approx_eq(deltas[0], 0.0));
assert!(approx_eq(deltas[1], 0.0));
assert!(approx_eq(deltas[2], 0.0), "snare at 0, got {}", deltas[2]);
}
#[test]
fn div_nested_with_sibling() {
// Inner div claims slot 0, snare claims slot 1
// Inner div's kick/hat subdivide slot 0
let outputs = expect_outputs(r#"div div "kick" s . "hat" s . ~ "snare" s . ~"#, 3);
let deltas = get_deltas(&outputs);
let sounds = get_sounds(&outputs);
// Outer div has 2 slots of 0.25 each
// Inner div at slot 0: kick at 0, hat at 0.125
// snare at slot 1: delta 0.25
assert_eq!(sounds[0], "kick");
assert_eq!(sounds[1], "hat");
assert_eq!(sounds[2], "snare");
assert!(approx_eq(deltas[0], 0.0), "kick at 0, got {}", deltas[0]);
assert!(approx_eq(deltas[1], 0.125), "hat at 0.125, got {}", deltas[1]);
assert!(approx_eq(deltas[2], 0.25), "snare at 0.25, got {}", deltas[2]);
}
#[test]
fn emit_n_basic() {
let outputs = expect_outputs(r#""kick" s 4 .!"#, 4);
@@ -383,4 +154,3 @@ fn emit_n_negative_error() {
let result = f.evaluate(r#""kick" s -1 .!"#, &default_ctx());
assert!(result.is_err());
}