w1n5t0n/ModuLisp
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
ModuLisp/test/signal_engine/test_signal_engine_golden.cpp

1907 lines
69 KiB
C++
Raw Normal View History

feat: extract ModuLisp engine from uSEQ (src-useq @1081ae8)
2026-08-17 13:38:51 +02:00
// Signal engine golden semantics.
//
// These tests are intentionally written at the language boundary: eval source
// text, sample named outputs, and assert user-visible values. Keep low-level
// node-shape tests in test_signal_engine.cpp.
#define CATCH_CONFIG_MAIN
#include "../catch.hpp"
#include "src/signal_engine/signal_engine.h"
#include <cmath>
#include <cstring>
#include <string>
#include <vector>
#include <initializer_list>
using namespace sig;
namespace {
struct Sample {
double t;
double expected;
double tolerance = 1e-9;
};
struct GoldenHarness {
SignalEngine engine;
double cell_values[MAX_CELLS] = {};
double hw_inputs[32] = {};
double outputs[MAX_OUTPUTS] = {};
double workspace[MAX_TOTAL_NODES] = {};
double prev_t = 0.0; // track previous tick time for dt
double last_dt = 0.0; // dt used for current tick
bool has_ticked = false; // false until first tick completes
bool state_committed_this_step = false; // prevents double-commit at same t
explicit GoldenHarness(double bpm = 120.0, int beats_per_bar = 4)
{
engine.init_defaults(bpm, beats_per_bar);
}
EvalResult eval_result(const std::string& code)
{
return eval_cold(code.c_str(), static_cast<uint32_t>(code.size()), engine);
}
void eval_ok(const std::string& code)
{
EvalResult r = eval_result(code);
INFO("code: " << code);
if (r.kind == EvalResult::Error && r.diagnostic_count > 0) {
INFO("diagnostic: " << (r.diagnostics[0].message ? r.diagnostics[0].message : ""));
INFO("suggestion: " << (r.diagnostics[0].suggestion ? r.diagnostics[0].suggestion : ""));
}
REQUIRE(r.kind != EvalResult::Error);
engine.pool.rebuild_execution_order();
}
void assign_ok(const char* output, const char* expr)
{
eval_ok(std::string("(") + output + " " + expr + ")");
}
uint16_t output_index(const char* output_name)
{
SymbolID sym = internSymbol(output_name);
uint16_t idx = GraphBuilder::resolve_output_index(sym);
REQUIRE(idx != NODE_NONE);
return idx;
}
double sample(const char* output_name, double t)
{
std::memset(outputs, 0, sizeof(outputs));
std::memset(workspace, 0, sizeof(workspace));
engine.cells.snapshot_values(cell_values, MAX_CELLS);
last_dt = t - prev_t;
// State update: at the start of each NEW time-step (after the very
// first tick), execute update graphs and commit state before outputs.
if (engine.pool.state_slot_count > 0 &&
has_ticked && t != prev_t && !state_committed_this_step)
{
// Execute all nodes to evaluate state update subgraphs
ExecutionContext state_ctx;
state_ctx.t = t;
state_ctx.dt = last_dt;
state_ctx.cell_values = cell_values;
state_ctx.hw_inputs = hw_inputs;
state_ctx.data_pool = engine.cells.data_pool;
state_ctx.data_offsets = engine.cells.data_offsets;
state_ctx.data_lengths = engine.cells.data_lengths;
state_ctx.prev_outputs = engine.pool.prev_output_values;
state_ctx.output_values = outputs;
state_ctx.workspace = workspace;
execute_all_outputs(engine.pool, state_ctx);
commit_state(engine.pool, workspace);
state_committed_this_step = true;
// Clear workspace and outputs for the real output evaluation
std::memset(workspace, 0, sizeof(workspace));
std::memset(outputs, 0, sizeof(outputs));
}
ExecutionContext ctx;
ctx.t = t;
ctx.dt = last_dt;
ctx.cell_values = cell_values;
ctx.hw_inputs = hw_inputs;
ctx.data_pool = engine.cells.data_pool;
ctx.data_offsets = engine.cells.data_offsets;
ctx.data_lengths = engine.cells.data_lengths;
ctx.prev_outputs = engine.pool.prev_output_values;
ctx.output_values = outputs;
ctx.workspace = workspace;
execute_all_outputs(engine.pool, ctx);
return outputs[output_index(output_name)];
}
double tick(const char* output_name, double t)
{
if (t != prev_t) {
state_committed_this_step = false;
}
double value = sample(output_name, t);
commit_outputs(engine.pool, outputs);
has_ticked = true;
prev_t = t;
return value;
}
// ── Diagnostic assertion helpers ───────────────────────────────────────
// Assert that eval produces a diagnostic with the expected category.
// Optionally check that message and suggestion contain given substrings.
void expect_error(const std::string& code,
DiagnosticCategory expected_cat,
const char* message_contains = nullptr,
const char* suggestion_contains = nullptr)
{
EvalResult r = eval_result(code);
INFO("code: " << code);
REQUIRE(r.kind == EvalResult::Error);
REQUIRE(r.diagnostic_count > 0);
bool found = false;
for (uint8_t i = 0; i < r.diagnostic_count; ++i) {
if (r.diagnostics[i].category == expected_cat) {
found = true;
if (message_contains) {
REQUIRE(r.diagnostics[i].message != nullptr);
INFO("expected message to contain: " << message_contains);
INFO("actual message: " << r.diagnostics[i].message);
REQUIRE(std::string(r.diagnostics[i].message)
.find(message_contains) != std::string::npos);
}
if (suggestion_contains) {
REQUIRE(r.diagnostics[i].suggestion != nullptr);
INFO("expected suggestion to contain: " << suggestion_contains);
INFO("actual suggestion: " << r.diagnostics[i].suggestion);
REQUIRE(std::string(r.diagnostics[i].suggestion)
.find(suggestion_contains) != std::string::npos);
}
break;
}
}
INFO("expected category: " << category_to_cstr(expected_cat));
REQUIRE(found);
}
// Assert that eval produces a diagnostic at an exact span location.
void expect_error_at(const std::string& code,
DiagnosticCategory expected_cat,
uint16_t span_start, uint16_t span_len,
const char* message_contains = nullptr)
{
EvalResult r = eval_result(code);
INFO("code: " << code);
REQUIRE(r.kind == EvalResult::Error);
REQUIRE(r.diagnostic_count > 0);
bool found = false;
for (uint8_t i = 0; i < r.diagnostic_count; ++i) {
if (r.diagnostics[i].category == expected_cat) {
found = true;
INFO("expected span_start: " << span_start
<< " actual: " << r.diagnostics[i].span_start);
REQUIRE(r.diagnostics[i].span_start == span_start);
INFO("expected span_len: " << span_len
<< " actual: " << r.diagnostics[i].span_len);
REQUIRE(r.diagnostics[i].span_len == span_len);
if (message_contains) {
REQUIRE(r.diagnostics[i].message != nullptr);
REQUIRE(std::string(r.diagnostics[i].message)
.find(message_contains) != std::string::npos);
}
break;
}
}
REQUIRE(found);
}
// Assert that a suggestion from a diagnostic compiles successfully.
// This validates that error suggestions are valid ModuLisp code.
void expect_suggestion_compiles(const std::string& code,
DiagnosticCategory expected_cat)
{
EvalResult r = eval_result(code);
REQUIRE(r.kind == EvalResult::Error);
REQUIRE(r.diagnostic_count > 0);
for (uint8_t i = 0; i < r.diagnostic_count; ++i) {
if (r.diagnostics[i].category == expected_cat &&
r.diagnostics[i].suggestion != nullptr) {
std::string suggestion = r.diagnostics[i].suggestion;
// Strip "Try: " prefix if present
if (suggestion.substr(0, 5) == "Try: ") {
suggestion = suggestion.substr(5);
}
// Only test suggestions that look like expressions
// (start with '(' or are a bare symbol)
if (!suggestion.empty() && suggestion[0] != 'C' &&
suggestion[0] != 'U' && suggestion[0] != 'E' &&
suggestion[0] != 'D') {
// Wrap in output assignment to test compilability
std::string test_code = "(a1 " + suggestion + ")";
EvalResult sr = eval_result(test_code);
INFO("suggestion code: " << test_code);
INFO("original error code: " << code);
// NOTE: Some suggestions are just symbol names, which might
// not be defined. We only check that parsing/compilation
// doesn't produce a Syntax error.
if (sr.kind == EvalResult::Error) {
for (uint8_t j = 0; j < sr.diagnostic_count; ++j) {
INFO("suggestion diagnostic: "
<< (sr.diagnostics[j].message ? sr.diagnostics[j].message : ""));
REQUIRE(sr.diagnostics[j].category != DiagnosticCategory::Syntax);
}
}
}
break;
}
}
}
// ── Sampling helpers ───────────────────────────────────────────────────
// Sample across a time window and return values.
std::vector<double> sample_window(const char* output,
double t_start, double t_end,
size_t count)
{
std::vector<double> result;
result.reserve(count);
for (size_t i = 0; i < count; ++i) {
double t_val = t_start + (t_end - t_start)
* static_cast<double>(i) / static_cast<double>(count - 1);
result.push_back(sample(output, t_val));
}
return result;
}
// ── Batch comparison helper ────────────────────────────────────────────
// Find the active-output index for batch buffer layout.
// execute_batch packs only outputs with root_node != NODE_NONE, in
// slot order. Returns the 0-based position of the requested output
// within the active set.
uint16_t batch_output_index(const char* output_name)
{
uint16_t slot = output_index(output_name);
uint16_t active = 0;
for (uint16_t o = 0; o < slot; o++) {
if (engine.pool.outputs[o].root_node != NODE_NONE)
active++;
}
return active;
}
// Verify batch execution matches single-sample across a time window.
void verify_batch_matches_single(const char* output,
double t_start, double t_end,
size_t count,
double tolerance = 1e-9)
{
engine.pool.allocate_batch_workspace();
std::vector<double> times(count);
for (size_t i = 0; i < count; ++i) {
times[i] = t_start + (t_end - t_start)
* static_cast<double>(i) / static_cast<double>(count - 1);
}
// Count active outputs for buffer sizing
uint16_t active_count = 0;
for (uint16_t o = 0; o < MAX_OUTPUTS; o++) {
if (engine.pool.outputs[o].root_node != NODE_NONE)
active_count++;
}
std::vector<double> batch_buf(active_count * count, 0.0);
engine.cells.snapshot_values(cell_values, MAX_CELLS);
execute_batch(engine.pool,
times.data(),
count,
cell_values,
hw_inputs,
engine.cells.data_pool,
engine.cells.data_offsets,
engine.cells.data_lengths,
batch_buf.data(),
active_count);
uint16_t idx = batch_output_index(output);
for (size_t i = 0; i < count; ++i) {
INFO("sample index: " << i << " t: " << times[i]);
double single_val = sample(output, times[i]);
REQUIRE(batch_buf[idx * count + i] == Approx(single_val).margin(tolerance));
}
}
// ── Multi-tick helper ──────────────────────────────────────────────────
// Execute a sequence of ticks and return committed values at each.
std::vector<double> tick_sequence(const char* output,
std::initializer_list<double> times)
{
std::vector<double> result;
result.reserve(times.size());
for (double t_val : times) {
result.push_back(tick(output, t_val));
}
return result;
}
};
void check_expr(const char* name,
const char* expr,
std::initializer_list<Sample> samples,
double bpm = 120.0,
int beats_per_bar = 4,
const char* setup = nullptr,
const char* output = "a1")
{
DYNAMIC_SECTION(name) {
GoldenHarness h(bpm, beats_per_bar);
if (setup) h.eval_ok(setup);
h.assign_ok(output, expr);
for (const Sample& sample : samples) {
INFO("expr: " << expr);
INFO("t: " << sample.t);
double actual = h.sample(output, sample.t);
REQUIRE(actual == Approx(sample.expected).margin(sample.tolerance));
}
}
}
EvalResult eval_output_error(const char* expr)
{
GoldenHarness h;
std::string code = std::string("(a1 ") + expr + ")";
return h.eval_result(code);
}
} // namespace
TEST_CASE("Golden semantics: numeric expressions are lifted into signals",
"[golden][signal_engine][semantics]") {
check_expr("constant arithmetic", "(+ 1 2)", {{0.0, 3.0}});
check_expr("variadic addition", "(+ 1 2 3 4)", {{0.0, 10.0}});
check_expr("variadic subtraction left folds", "(- 100 30 20 10)", {{0.0, 40.0}});
check_expr("unary negation form", "(- 5)", {{0.0, -5.0}});
check_expr("legacy pow order is exponent then base", "(pow 2 10)", {{0.0, 100.0}});
check_expr("standard expt order is base then exponent", "(expt 2 10)", {{0.0, 1024.0}});
check_expr("fractional arithmetic", "(+ 0.1 0.2)", {{0.0, 0.3, 1e-6}});
check_expr("division fraction", "(/ 1 3)", {{0.0, 1.0 / 3.0, 1e-9}});
check_expr("constant folding is time-invariant",
"(+ (* 2 3) 4)",
{{0.0, 10.0}, {0.5, 10.0}, {1.0, 10.0}});
check_expr("numeric truthiness treats any non-zero as true", "(if -0.1 7 9)", {{0.0, 7.0}});
check_expr("and returns numeric truth", "(and 2 -3)", {{0.0, 1.0}});
check_expr("or returns numeric truth", "(or 0 -2)", {{0.0, 1.0}});
check_expr("if without else defaults to zero", "(if 0 42)", {{0.0, 0.0}});
check_expr("clamp below range", "(clamp 0 3 -1)", {{0.0, 0.0}});
check_expr("clamp above range", "(clamp 0 3 5)", {{0.0, 3.0}});
check_expr("lerp midpoint", "(lerp 0 10 0.5)", {{0.0, 5.0}});
check_expr("scale unipolar value", "(scale 100 200 0.5)", {{0.0, 150.0}});
}
TEST_CASE("Golden semantics: time, phasors, and time substitutions",
"[golden][signal_engine][time]") {
check_expr("raw t is seconds", "t", {{0.0, 0.0}, {1.25, 1.25}});
check_expr("beat phasor at 120 bpm",
"beat",
{{0.0, 0.0}, {0.125, 0.25}, {0.25, 0.5}, {0.5, 0.0}});
check_expr("beat phasor at 60 bpm",
"beat",
{{0.0, 0.0}, {0.5, 0.5}, {1.0, 0.0}},
60.0);
check_expr("bar phasor at 120 bpm 4/4",
"bar",
{{0.0, 0.0}, {0.5, 0.25}, {1.0, 0.5}, {2.0, 0.0}});
check_expr("phrase phasor uses bars-per-phrase default",
"phrase",
{{0.0, 0.0}, {4.0, 0.5}, {8.0, 0.0}});
check_expr("section phasor uses phrase defaults",
"section",
{{0.0, 0.0}, {16.0, 0.5}, {32.0, 0.0}});
check_expr("beat-num is an unwrapped counter",
"beat-num",
{{0.0, 0.0}, {0.49, 0.0}, {0.5, 1.0}, {1.25, 2.0}});
check_expr("bar-num is an unwrapped counter",
"bar-num",
{{0.0, 0.0}, {1.99, 0.0}, {2.0, 1.0}, {4.1, 2.0}});
check_expr("beat-dur follows bpm", "beat-dur", {{0.0, 0.5}}, 120.0);
check_expr("bar-dur follows metre", "bar-dur", {{0.0, 1.5}}, 120.0, 3);
check_expr("fast doubles local time", "(fast 2 beat)", {{0.125, 0.5}, {0.25, 0.0}});
check_expr("slow halves local time", "(slow 2 beat)", {{0.25, 0.25}, {0.5, 0.5}});
check_expr("nested constant warps compose",
"(fast 2 (slow 4 beat))",
{{0.5, 0.5}, {1.0, 0.0}});
check_expr("dynamic fast is pointwise substitution",
"(fast (+ 1 beat) beat)",
{{0.125, 0.3125}});
check_expr("offset uses seconds",
"(offset 0.25 beat)",
{{0.0, 0.5}, {0.125, 0.75}});
check_expr("shift aliases offset",
"(shift 0.25 beat)",
{{0.0, 0.5}, {0.125, 0.75}});
check_expr("musical offset can use beat-dur",
"(offset (* 0.5 beat-dur) beat)",
{{0.0, 0.5}});
}
TEST_CASE("Golden semantics: waveform and sequence helpers",
"[golden][signal_engine][sequences]") {
check_expr("sin is unipolar sine over normalized phase",
"(sin beat)",
{{0.0, 0.5, 1e-9}, {0.125, 1.0, 1e-9}, {0.375, 0.0, 1e-9}});
check_expr("cos is unipolar cosine over normalized phase",
"(cos beat)",
{{0.0, 1.0, 1e-9}, {0.25, 0.0, 1e-9}});
check_expr("tri maps one phase value", "(tri 0.25)", {{0.0, 0.5, 1e-9}});
check_expr("sqr thresholds phase at half", "(sqr beat)", {{0.125, 1.0}, {0.375, 0.0}});
check_expr("pulse reads width before its final phasor", "(pulse 0.25 beat)", {{0.1, 1.0}, {0.2, 0.0}});
check_expr("bipolar to unipolar", "(b>u -1)", {{0.0, 0.0}});
check_expr("unipolar to bipolar", "(u>b 0.25)", {{0.0, -0.5}});
check_expr("step over literal vector",
"(step [10 20 30 40] beat)",
{{0.0, 10.0}, {0.125, 20.0}, {0.25, 30.0}, {0.375, 40.0}});
check_expr("from-list is stepped lookup",
"(from-list [10 20 30] beat)",
{{0.0, 10.0}, {0.25, 20.0}, {0.49, 30.0}});
check_expr("seq aliases from-list", "(seq [100 200] beat)", {{0.0, 100.0}, {0.25, 200.0}});
check_expr("interp linearly interpolates",
"(interp [0 1 0] beat)",
{{0.0, 0.0}, {0.125, 0.5}, {0.25, 1.0}, {0.375, 0.5}});
check_expr("gates follows pattern", "(gates [1 0 1 0] beat)", {{0.0, 1.0}, {0.125, 0.0}});
check_expr("trigs aliases gates", "(trigs [1 0 1 0] beat)", {{0.0, 1.0}, {0.125, 0.0}});
check_expr("euclid distributes hits", "(euclid 3 8 beat)", {{0.0, 1.0}, {0.125, 0.0}});
}
TEST_CASE("Golden semantics: top-level cells, functions, and reactivity",
"[golden][signal_engine][reactivity]") {
check_expr("number cell reference",
"freq",
{{0.0, 440.0}},
120.0,
4,
"(define freq 440)");
check_expr("expression cell is time-varying",
"sweep",
{{0.0, 200.0}, {0.25, 250.0}},
120.0,
4,
"(define sweep (+ 200 (* 200 t)))");
check_expr("data cell feeds step",
"(step pattern beat)",
{{0.0, 10.0}, {0.25, 30.0}},
120.0,
4,
"(define pattern [10 20 30 40])");
check_expr("defn with one argument inlines at call site",
"(double 5)",
{{0.0, 10.0}},
120.0,
4,
"(defn double [x] (* x 2))");
check_expr("defn inherits caller time context",
"(fast 2 (scaled-beat 3))",
{{0.125, 1.5}},
120.0,
4,
"(defn scaled-beat [s] (* s beat))");
SECTION("redefining a depended-on cell recompiles output") {
GoldenHarness h;
h.eval_ok("(define freq 440)");
h.assign_ok("a1", "freq");
REQUIRE(h.sample("a1", 0.0) == Approx(440.0));
h.eval_ok("(define freq 880)");
REQUIRE(h.sample("a1", 0.0) == Approx(880.0));
}
SECTION("function redefinition recompiles callers") {
GoldenHarness h;
h.eval_ok("(defn f [x] (* x 2))");
h.assign_ok("a1", "(f 5)");
REQUIRE(h.sample("a1", 0.0) == Approx(10.0));
h.eval_ok("(defn f [x] (* x 3))");
REQUIRE(h.sample("a1", 0.0) == Approx(15.0));
}
}
TEST_CASE("Golden semantics: outputs, prev, inputs, and batch execution",
"[golden][signal_engine][execution]") {
SECTION("unassigned outputs use neutral zero") {
GoldenHarness h;
REQUIRE(h.sample("a1", 0.0) == Approx(0.0));
REQUIRE(h.sample("d1", 0.0) == Approx(0.0));
}
SECTION("bare output reference reads previous committed sample") {
GoldenHarness h;
h.eval_ok("(a1 0.75) (a2 a1)");
REQUIRE(h.tick("a2", 0.0) == Approx(0.0));
REQUIRE(h.tick("a2", 0.001) == Approx(0.75));
}
SECTION("explicit prev reads previous committed sample") {
GoldenHarness h;
h.eval_ok("(d1 1.0) (a1 (prev d1))");
REQUIRE(h.tick("a1", 0.0) == Approx(0.0));
REQUIRE(h.tick("a1", 0.001) == Approx(1.0));
}
SECTION("hardware input leaves read injected input values") {
GoldenHarness h;
h.hw_inputs[0] = 1.0; // in1 (INP_I1)
h.hw_inputs[8] = 0.25; // ain1 (INP_AI1)
h.assign_ok("a1", "(+ in1 ain1)");
REQUIRE(h.sample("a1", 0.0) == Approx(1.25));
}
SECTION("batch execution matches single-sample execution") {
GoldenHarness h;
h.assign_ok("a1", "(+ (sin beat) (* 0.25 bar))");
h.engine.pool.allocate_batch_workspace();
constexpr size_t sample_count = 5;
double times[sample_count] = {0.0, 0.125, 0.25, 0.375, 0.5};
double batch[MAX_OUTPUTS * sample_count] = {};
h.engine.cells.snapshot_values(h.cell_values, MAX_CELLS);
execute_batch(h.engine.pool,
times,
sample_count,
h.cell_values,
h.hw_inputs,
h.engine.cells.data_pool,
h.engine.cells.data_offsets,
h.engine.cells.data_lengths,
batch,
MAX_OUTPUTS);
for (size_t i = 0; i < sample_count; ++i) {
INFO("sample index: " << i);
double single = h.sample("a1", times[i]);
REQUIRE(batch[i] == Approx(single).margin(1e-9));
}
}
}
TEST_CASE("Golden semantics: diagnostics and failure isolation",
"[golden][signal_engine][diagnostics]") {
SECTION("unknown names produce a diagnostic with fuzzy suggestions") {
GoldenHarness h;
h.eval_ok("(define freq 440)");
EvalResult r = h.eval_result("(a1 frq)");
REQUIRE(r.kind == EvalResult::Error);
REQUIRE(r.diagnostic_count > 0);
REQUIRE(r.diagnostics[0].severity == DiagnosticSeverity::Error);
REQUIRE(r.diagnostics[0].span_start == 4);
REQUIRE(r.diagnostics[0].span_len == 3);
REQUIRE(r.diagnostics[0].message != nullptr);
REQUIRE(std::string(r.diagnostics[0].message).find("freq") != std::string::npos);
REQUIRE(r.diagnostics[0].suggestion != nullptr);
}
SECTION("side effects are rejected inside output expressions") {
EvalResult r = eval_output_error("(define x 1)");
REQUIRE(r.kind == EvalResult::Error);
REQUIRE(r.diagnostic_count > 0);
REQUIRE(r.diagnostics[0].severity == DiagnosticSeverity::Error);
REQUIRE(r.diagnostics[0].message != nullptr);
REQUIRE(std::string(r.diagnostics[0].message).find("inside an output") != std::string::npos);
}
SECTION("recursion is rejected instead of hanging") {
GoldenHarness h;
h.eval_ok("(defn f [x] (f x))");
EvalResult r = h.eval_result("(a1 (f 1))");
REQUIRE(r.kind == EvalResult::Error);
REQUIRE(r.diagnostic_count > 0);
REQUIRE(r.diagnostics[0].message != nullptr);
REQUIRE(std::string(r.diagnostics[0].message).find("recursive") != std::string::npos);
}
SECTION("compile error leaves previous output running") {
GoldenHarness h;
h.assign_ok("a1", "(+ beat 1)");
REQUIRE(h.sample("a1", 0.25) == Approx(1.5));
EvalResult bad = h.eval_result("(a1 (unknown-name beat))");
REQUIRE(bad.kind == EvalResult::Error);
REQUIRE(h.sample("a1", 0.25) == Approx(1.5));
}
SECTION("one output compile error does not affect another output") {
GoldenHarness h;
h.assign_ok("a1", "0.2");
h.assign_ok("a2", "0.8");
EvalResult bad = h.eval_result("(a1 (not-a-function 1))");
REQUIRE(bad.kind == EvalResult::Error);
REQUIRE(h.sample("a1", 0.0) == Approx(0.2));
REQUIRE(h.sample("a2", 0.0) == Approx(0.8));
}
SECTION("expect_error helper: unknown name produces error with message") {
GoldenHarness h;
h.expect_error("(a1 nonexistent)", DiagnosticCategory::UndefinedName,
"Unknown");
}
SECTION("expect_error_at helper: span points at the bad symbol") {
GoldenHarness h;
h.eval_ok("(define freq 440)");
// "(a1 frq)" — 'frq' starts at offset 4, length 3
h.expect_error_at("(a1 frq)",
DiagnosticCategory::UndefinedName,
4, 3, "freq");
}
SECTION("expect_error helper: side effects rejected") {
GoldenHarness h;
h.expect_error("(a1 (define x 1))",
DiagnosticCategory::Boundary,
"inside an output");
}
}
TEST_CASE("Golden semantics: sample_window and tick_sequence helpers",
"[golden][signal_engine][helpers]") {
SECTION("sample_window returns correct count and values") {
GoldenHarness h;
h.assign_ok("a1", "t");
auto window = h.sample_window("a1", 0.0, 1.0, 5);
REQUIRE(window.size() == 5);
REQUIRE(window[0] == Approx(0.0));
REQUIRE(window[1] == Approx(0.25));
REQUIRE(window[2] == Approx(0.5));
REQUIRE(window[3] == Approx(0.75));
REQUIRE(window[4] == Approx(1.0));
}
SECTION("tick_sequence returns committed values at each step") {
GoldenHarness h;
h.eval_ok("(a1 0.75) (a2 a1)");
auto seq = h.tick_sequence("a2", {0.0, 0.001, 0.002});
REQUIRE(seq.size() == 3);
REQUIRE(seq[0] == Approx(0.0)); // no prev yet
REQUIRE(seq[1] == Approx(0.75)); // prev a1 is now 0.75
REQUIRE(seq[2] == Approx(0.75)); // still 0.75
}
SECTION("verify_batch_matches_single for a compound expression") {
GoldenHarness h;
h.assign_ok("a1", "(+ (sin beat) (* 0.1 bar))");
h.verify_batch_matches_single("a1", 0.0, 1.0, 10);
}
SECTION("verify_batch_matches_single for constant expression") {
GoldenHarness h;
h.assign_ok("a1", "42");
h.verify_batch_matches_single("a1", 0.0, 2.0, 8);
}
}
TEST_CASE("Golden semantics: additional coverage for spec gaps",
"[golden][signal_engine][coverage]") {
SECTION("variadic multiply folds correctly") {
GoldenHarness h;
h.assign_ok("a1", "(* 2 3 4)");
REQUIRE(h.sample("a1", 0.0) == Approx(24.0));
}
SECTION("binary division") {
GoldenHarness h;
h.assign_ok("a1", "(/ 10 4)");
REQUIRE(h.sample("a1", 0.0) == Approx(2.5));
}
SECTION("variadic division left folds") {
GoldenHarness h;
h.assign_ok("a1", "(/ 120 2 3)");
REQUIRE(h.sample("a1", 0.0) == Approx(20.0));
}
SECTION("min selects minimum of two") {
GoldenHarness h;
h.assign_ok("a1", "(min 5 2)");
REQUIRE(h.sample("a1", 0.0) == Approx(2.0));
}
SECTION("max selects maximum of two") {
GoldenHarness h;
h.assign_ok("a1", "(max 5 2)");
REQUIRE(h.sample("a1", 0.0) == Approx(5.0));
}
SECTION("nil is falsy in if") {
GoldenHarness h;
h.assign_ok("a1", "(if 0 10 20)");
REQUIRE(h.sample("a1", 0.0) == Approx(20.0));
}
SECTION("nested if picks correct branch") {
GoldenHarness h;
h.assign_ok("a1", "(if 1 (if 0 10 20) 30)");
REQUIRE(h.sample("a1", 0.0) == Approx(20.0));
}
SECTION("let creates local scope") {
GoldenHarness h;
h.assign_ok("a1", "(let [x 10 y 20] (+ x y))");
REQUIRE(h.sample("a1", 0.0) == Approx(30.0));
}
SECTION("data cell with time-varying lookup") {
GoldenHarness h;
h.eval_ok("(define notes [60 64 67 72])");
h.assign_ok("a1", "(interp notes beat)");
// At t=0.0, beat=0.0, scaled=0*3=0, interp = notes[0] = 60
REQUIRE(h.sample("a1", 0.0) == Approx(60.0));
// At t=0.25, beat=0.5, scaled=0.5*3=1.5, interp = 64 + 0.5*(67-64) = 65.5
REQUIRE(h.sample("a1", 0.25) == Approx(65.5));
}
SECTION("diamond dependency: redefining root propagates through chain") {
GoldenHarness h;
h.eval_ok("(define root 1)");
h.eval_ok("(define mid (+ root 10))");
h.assign_ok("a1", "(+ mid 100)");
REQUIRE(h.sample("a1", 0.0) == Approx(111.0));
h.eval_ok("(define root 5)");
REQUIRE(h.sample("a1", 0.0) == Approx(115.0));
}
SECTION("self-reference via prev for integration") {
GoldenHarness h;
h.eval_ok("(a1 (+ (prev a1) 0.1))");
auto seq = h.tick_sequence("a1", {0.0, 0.001, 0.002, 0.003});
REQUIRE(seq[0] == Approx(0.1)); // prev starts at 0
REQUIRE(seq[1] == Approx(0.2));
REQUIRE(seq[2] == Approx(0.3));
REQUIRE(seq[3] == Approx(0.4));
}
SECTION("fast does not affect cells defined outside the warp") {
GoldenHarness h;
h.eval_ok("(define k 10)");
h.assign_ok("a1", "(fast 2 (+ k beat))");
// At t=0.125, fast-2 makes local t=0.25, beat=0.5, k=10 (unchanged)
REQUIRE(h.sample("a1", 0.125) == Approx(10.5));
}
SECTION("phrase phasor wraps at expected period") {
GoldenHarness h(120.0, 4);
h.assign_ok("a1", "phrase");
// At 120 bpm, 4/4, bars_per_phrase=4: one phrase = 4 bars = 8 seconds
REQUIRE(h.sample("a1", 0.0) == Approx(0.0));
REQUIRE(h.sample("a1", 4.0) == Approx(0.5));
// At exactly 8.0 it wraps back to 0
REQUIRE(h.sample("a1", 8.0) == Approx(0.0).margin(1e-9));
}
SECTION("section phasor wraps at expected period") {
GoldenHarness h(120.0, 4);
h.assign_ok("a1", "section");
// 4 phrases per section, each phrase = 8s, so section = 32s
REQUIRE(h.sample("a1", 0.0) == Approx(0.0));
REQUIRE(h.sample("a1", 16.0) == Approx(0.5));
REQUIRE(h.sample("a1", 32.0) == Approx(0.0).margin(1e-9));
}
SECTION("recursion rejection includes message about 'recursive'") {
GoldenHarness h;
h.eval_ok("(defn g [x] (g x))");
h.expect_error("(a1 (g 1))", DiagnosticCategory::Runtime,
"recursive");
}
SECTION("defs batch define works") {
GoldenHarness h;
h.eval_ok("(defs [x 10 y 20])");
h.assign_ok("a1", "(+ x y)");
REQUIRE(h.sample("a1", 0.0) == Approx(30.0));
}
SECTION("fn anonymous lambda in signal context is rejected") {
GoldenHarness h;
h.expect_error("(a1 (fn [x] (* x 2)))", DiagnosticCategory::Boundary,
"Lambda");
}
SECTION("defn with multiple arguments") {
GoldenHarness h;
h.eval_ok("(defn add3 [a b c] (+ a b c))");
h.assign_ok("a1", "(add3 1 2 3)");
REQUIRE(h.sample("a1", 0.0) == Approx(6.0));
}
SECTION("multiple outputs are independent") {
GoldenHarness h;
h.assign_ok("a1", "0.25");
h.assign_ok("a2", "0.75");
h.assign_ok("d1", "1.0");
REQUIRE(h.sample("a1", 0.0) == Approx(0.25));
REQUIRE(h.sample("a2", 0.0) == Approx(0.75));
REQUIRE(h.sample("d1", 0.0) == Approx(1.0));
}
SECTION("sample_window over beat shows monotonic ramp") {
GoldenHarness h;
h.assign_ok("a1", "beat");
// Half a beat at 120 bpm = 0.25 seconds
auto window = h.sample_window("a1", 0.0, 0.25, 5);
REQUIRE(window.size() == 5);
for (size_t i = 1; i < window.size(); ++i) {
INFO("window[" << i-1 << "]=" << window[i-1]
<< " window[" << i << "]=" << window[i]);
REQUIRE(window[i] > window[i-1]);
}
}
}
// ============================================================================
// Phase 2: Close core semantic spec gaps
// ============================================================================
TEST_CASE("Golden semantics: variadic arithmetic edge cases (functions.md 1.7)",
"[golden][signal_engine][variadic]") {
SECTION("(+) nullary returns identity 0") {
GoldenHarness h;
h.assign_ok("a1", "(+)");
REQUIRE(h.sample("a1", 0.0) == Approx(0.0));
}
SECTION("(*) nullary returns identity 1") {
GoldenHarness h;
h.assign_ok("a1", "(*)");
REQUIRE(h.sample("a1", 0.0) == Approx(1.0));
}
SECTION("(/ x) unary division returns reciprocal (/ 1 x)") {
GoldenHarness h;
h.assign_ok("a1", "(/ 4)");
REQUIRE(h.sample("a1", 0.0) == Approx(0.25));
}
SECTION("(- x) unary negation") {
GoldenHarness h;
h.assign_ok("a1", "(- 7)");
REQUIRE(h.sample("a1", 0.0) == Approx(-7.0));
}
SECTION("variadic min with 3 args") {
GoldenHarness h;
h.assign_ok("a1", "(min 5 2 8)");
REQUIRE(h.sample("a1", 0.0) == Approx(2.0));
}
SECTION("variadic min with 4 args") {
GoldenHarness h;
h.assign_ok("a1", "(min 10 3 7 1)");
REQUIRE(h.sample("a1", 0.0) == Approx(1.0));
}
SECTION("variadic max with 3 args") {
GoldenHarness h;
h.assign_ok("a1", "(max 5 2 8)");
REQUIRE(h.sample("a1", 0.0) == Approx(8.0));
}
SECTION("variadic max with 4 args") {
GoldenHarness h;
h.assign_ok("a1", "(max 1 9 3 6)");
REQUIRE(h.sample("a1", 0.0) == Approx(9.0));
}
}
TEST_CASE("Golden semantics: arity boundary errors",
"[golden][signal_engine][arity]") {
SECTION("(sin) with no args errors") {
GoldenHarness h;
h.expect_error("(a1 (sin))", DiagnosticCategory::Arity);
}
SECTION("(sin 1 2) with too many args errors") {
GoldenHarness h;
h.expect_error("(a1 (sin 1 2))", DiagnosticCategory::Arity);
}
SECTION("(clamp 1 2) missing third arg errors") {
GoldenHarness h;
h.expect_error("(a1 (clamp 1 2))", DiagnosticCategory::Arity);
}
SECTION("(step [1 2 3]) with no phasor defaults to beat (no error)") {
GoldenHarness h;
h.assign_ok("a1", "(step [1 2 3])");
REQUIRE(h.sample("a1", 0.0) == Approx(1.0));
}
SECTION("(euclid 3) with only one arg errors") {
GoldenHarness h;
h.expect_error("(a1 (euclid 3))", DiagnosticCategory::Arity);
}
SECTION("error messages are plain language, not jargon") {
GoldenHarness h;
EvalResult r = h.eval_result("(a1 (sin))");
REQUIRE(r.kind == EvalResult::Error);
REQUIRE(r.diagnostic_count > 0);
std::string msg = r.diagnostics[0].message ? r.diagnostics[0].message : "";
INFO("message: " << msg);
REQUIRE(msg.find("arity") == std::string::npos);
}
}
TEST_CASE("Golden semantics: let/do/if edge cases",
"[golden][signal_engine][control_flow]") {
SECTION("(do expr1 expr2) returns last value") {
GoldenHarness h;
h.assign_ok("a1", "(do 1 2 3)");
REQUIRE(h.sample("a1", 0.0) == Approx(3.0));
}
SECTION("(let [] 42) empty bindings returns body") {
GoldenHarness h;
h.assign_ok("a1", "(let [] 42)");
REQUIRE(h.sample("a1", 0.0) == Approx(42.0));
}
SECTION("let bindings can reference earlier bindings (let* semantics)") {
GoldenHarness h;
h.assign_ok("a1", "(let [x 1 y (+ x 1)] y)");
REQUIRE(h.sample("a1", 0.0) == Approx(2.0));
}
SECTION("if without else returns 0 for false condition") {
GoldenHarness h;
h.assign_ok("a1", "(if 0 42)");
REQUIRE(h.sample("a1", 0.0) == Approx(0.0));
}
SECTION("if without else returns value for true condition") {
GoldenHarness h;
h.assign_ok("a1", "(if 1 42)");
REQUIRE(h.sample("a1", 0.0) == Approx(42.0));
}
SECTION("nested let in signal context works") {
GoldenHarness h;
h.assign_ok("a1", "(let [x (+ beat 1)] (let [y (* x 2)] y))");
REQUIRE(h.sample("a1", 0.0) == Approx(2.0));
REQUIRE(h.sample("a1", 0.125) == Approx(2.5));
}
SECTION("let with time-varying binding") {
GoldenHarness h;
h.assign_ok("a1", "(let [x beat] (* x 10))");
REQUIRE(h.sample("a1", 0.125) == Approx(2.5));
}
SECTION("do with multiple expressions returns last") {
GoldenHarness h;
h.assign_ok("a1", "(do (+ 1 2) (* 3 4) (- 10 1))");
REQUIRE(h.sample("a1", 0.0) == Approx(9.0));
}
}
TEST_CASE("Golden semantics: sequence/index boundary cases",
"[golden][signal_engine][sequences_boundary]") {
SECTION("step with single-element vector returns constant") {
GoldenHarness h;
h.assign_ok("a1", "(step [42] beat)");
REQUIRE(h.sample("a1", 0.0) == Approx(42.0));
REQUIRE(h.sample("a1", 0.25) == Approx(42.0));
REQUIRE(h.sample("a1", 0.499) == Approx(42.0));
}
SECTION("interp with single element returns that value") {
GoldenHarness h;
h.assign_ok("a1", "(interp [5] beat)");
REQUIRE(h.sample("a1", 0.0) == Approx(5.0));
REQUIRE(h.sample("a1", 0.25) == Approx(5.0));
}
SECTION("from-list at exact boundaries") {
GoldenHarness h;
h.assign_ok("a1", "(from-list [10 20 30] beat)");
REQUIRE(h.sample("a1", 0.0) == Approx(10.0));
REQUIRE(h.sample("a1", 0.25) == Approx(20.0));
}
SECTION("large vector step (32 elements)") {
GoldenHarness h;
h.assign_ok("a1", "(step [0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31] beat)");
REQUIRE(h.sample("a1", 0.0) == Approx(0.0));
REQUIRE(h.sample("a1", 0.25) == Approx(16.0));
}
SECTION("step with empty vector returns zero") {
GoldenHarness h;
h.assign_ok("a1", "(step [] beat)");
REQUIRE(h.sample("a1", 0.0) == Approx(0.0));
}
SECTION("gates with empty vector returns zero") {
GoldenHarness h;
h.assign_ok("a1", "(gates [] beat)");
REQUIRE(h.sample("a1", 0.0) == Approx(0.0));
}
}
TEST_CASE("Golden semantics: for unrolling (compilation.md 1.8)",
"[golden][signal_engine][for_loop]") {
SECTION("basic for returns last iteration value") {
GoldenHarness h;
h.assign_ok("a1", "(for x [1 2 3] x)");
REQUIRE(h.sample("a1", 0.0) == Approx(3.0));
}
SECTION("for producing signal expression") {
GoldenHarness h;
h.assign_ok("a1", "(for x [1 2 3] (* x beat))");
REQUIRE(h.sample("a1", 0.125) == Approx(0.75));
}
SECTION("for with accumulation via let") {
GoldenHarness h;
h.assign_ok("a1", "(for x [10 20 30] (+ x 5))");
REQUIRE(h.sample("a1", 0.0) == Approx(35.0));
}
SECTION("for with empty collection returns 0") {
GoldenHarness h;
h.assign_ok("a1", "(for x [] x)");
REQUIRE(h.sample("a1", 0.0) == Approx(0.0));
}
}
TEST_CASE("Golden semantics: quote and symbol rejection",
"[golden][signal_engine][quote]") {
SECTION("(quote x) in signal context is rejected") {
GoldenHarness h;
h.expect_error("(a1 (quote x))", DiagnosticCategory::Boundary,
"quote");
}
}
TEST_CASE("Golden semantics: alias semantics verification",
"[golden][signal_engine][aliases]") {
SECTION("from-list and seq produce identical results") {
GoldenHarness h;
h.assign_ok("a1", "(from-list [10 20 30] beat)");
h.assign_ok("a2", "(seq [10 20 30] beat)");
auto w1 = h.sample_window("a1", 0.0, 0.49, 10);
auto w2 = h.sample_window("a2", 0.0, 0.49, 10);
for (size_t i = 0; i < w1.size(); ++i) {
INFO("i: " << i);
REQUIRE(w1[i] == Approx(w2[i]));
}
}
SECTION("trigs is binary (no width), gates has 50% duty cycle") {
GoldenHarness h;
h.assign_ok("a1", "(gates [1 1 1 1] beat)");
h.assign_ok("a2", "(trigs [1 1 1 1] beat)");
// trigs stays on for the whole step; gates turns off at 50%
auto wg = h.sample_window("a1", 0.0, 0.49, 10);
auto wt = h.sample_window("a2", 0.0, 0.49, 10);
// At the start of a step both should be 1
REQUIRE(wg[0] == 1.0);
REQUIRE(wt[0] == 1.0);
// trigs should always be 1 for a non-zero pattern
for (size_t i = 0; i < wt.size(); ++i) {
REQUIRE(wt[i] == 1.0);
}
}
SECTION("shift and offset produce identical results") {
GoldenHarness h;
h.assign_ok("a1", "(offset 0.1 beat)");
h.assign_ok("a2", "(shift 0.1 beat)");
auto w1 = h.sample_window("a1", 0.0, 0.49, 10);
auto w2 = h.sample_window("a2", 0.0, 0.49, 10);
for (size_t i = 0; i < w1.size(); ++i) {
INFO("i: " << i);
REQUIRE(w1[i] == Approx(w2[i]));
}
}
SECTION("expt and pow have consistent but different arg order") {
GoldenHarness h;
h.assign_ok("a1", "(expt 2 10)");
REQUIRE(h.sample("a1", 0.0) == Approx(1024.0));
h.assign_ok("a2", "(pow 2 10)");
REQUIRE(h.sample("a2", 0.0) == Approx(100.0));
}
}
TEST_CASE("Golden semantics: non-numeric roots and string diagnostics",
"[golden][signal_engine][type_errors]") {
SECTION("string literal in output context produces error") {
GoldenHarness h;
EvalResult r = h.eval_result("(a1 \"hello\")");
REQUIRE(r.kind == EvalResult::Error);
REQUIRE(r.diagnostic_count > 0);
}
}
// ============================================================================
// Phase 3: Diagnostic Categories as First-Class Compiler Contract
// ============================================================================
TEST_CASE("Diagnostics: UndefinedName category",
"[golden][signal_engine][diagnostics][category]") {
SECTION("unknown bare symbol produces UndefinedName") {
GoldenHarness h;
h.expect_error("(a1 nonexistent)", DiagnosticCategory::UndefinedName,
"Unknown");
}
SECTION("typo with fuzzy match produces UndefinedName with suggestion") {
GoldenHarness h;
h.eval_ok("(define freq 440)");
h.expect_error("(a1 frq)", DiagnosticCategory::UndefinedName,
"freq", "freq");
}
SECTION("typo sni suggests sin") {
GoldenHarness h;
h.expect_error("(a1 (sni beat))", DiagnosticCategory::UndefinedName,
"sin", "sin");
}
SECTION("totally unknown symbol still gets UndefinedName category") {
GoldenHarness h;
h.expect_error("(a1 zzzzzzz)", DiagnosticCategory::UndefinedName,
"Unknown");
}
SECTION("unknown function in call position produces UndefinedName") {
GoldenHarness h;
h.expect_error("(a1 (not-a-function 1))", DiagnosticCategory::UndefinedName);
}
SECTION("user-defined symbol typo gets fuzzy match") {
GoldenHarness h;
h.eval_ok("(define tempo 120)");
h.expect_error("(a1 tmpo)", DiagnosticCategory::UndefinedName,
"tempo");
}
}
TEST_CASE("Diagnostics: Boundary category",
"[golden][signal_engine][diagnostics][category]") {
SECTION("define inside output is Boundary") {
GoldenHarness h;
h.expect_error("(a1 (define x 1))", DiagnosticCategory::Boundary,
"inside an output");
}
SECTION("defn inside output is Boundary") {
GoldenHarness h;
h.expect_error("(a1 (defn f [x] x))", DiagnosticCategory::Boundary,
"inside an output");
}
SECTION("lambda inside output is Boundary") {
GoldenHarness h;
h.expect_error("(a1 (fn [x] (* x 2)))", DiagnosticCategory::Boundary,
"Lambda");
}
SECTION("set inside output is Boundary") {
GoldenHarness h;
h.expect_error("(a1 (set x 1))", DiagnosticCategory::Boundary,
"inside an output");
}
SECTION("quote inside output is Boundary") {
GoldenHarness h;
h.expect_error("(a1 (quote (1 2 3)))", DiagnosticCategory::Boundary,
"quote");
}
}
TEST_CASE("Diagnostics: Arity category",
"[golden][signal_engine][diagnostics][category]") {
SECTION("user function with too many args is Arity") {
GoldenHarness h;
h.eval_ok("(defn double [x] (* x 2))");
h.expect_error("(a1 (double 1 2))", DiagnosticCategory::Arity,
"Too many");
}
SECTION("user function with zero args when it needs one is Arity") {
GoldenHarness h;
h.eval_ok("(defn double [x] (* x 2))");
h.expect_error("(a1 (double))", DiagnosticCategory::Arity,
"Wrong number");
}
SECTION("bare function name (needs args) is Arity") {
GoldenHarness h;
h.eval_ok("(defn f [x] (* x 2))");
h.expect_error("(a1 f)", DiagnosticCategory::Arity,
"needs arguments");
}
}
TEST_CASE("Diagnostics: Syntax category",
"[golden][signal_engine][diagnostics][category]") {
SECTION("non-symbol after open paren is Syntax") {
GoldenHarness h;
h.expect_error("(a1 (123 beat))", DiagnosticCategory::Syntax,
"Expected a function name");
}
SECTION("for with non-symbol variable is Syntax") {
GoldenHarness h;
h.expect_error("(a1 (for 123 [1 2 3] 1))", DiagnosticCategory::Syntax,
"'for' needs a variable name");
}
SECTION("unclosed form at EOF is Syntax") {
GoldenHarness h;
h.expect_error("(a1 (+ 1 2", DiagnosticCategory::Syntax,
"Unclosed form");
}
}
TEST_CASE("Diagnostics: Type category",
"[golden][signal_engine][diagnostics][category]") {
SECTION("prev with non-output name is Type") {
GoldenHarness h;
h.expect_error("(a1 (prev beat))", DiagnosticCategory::Type,
"output name");
}
}
TEST_CASE("Diagnostics: Runtime category (correct usage)",
"[golden][signal_engine][diagnostics][category]") {
SECTION("direct recursion is Runtime") {
GoldenHarness h;
h.eval_ok("(defn g [x] (g x))");
h.expect_error("(a1 (g 1))", DiagnosticCategory::Runtime,
"recursive");
}
SECTION("mutual recursion is Runtime") {
GoldenHarness h;
h.eval_ok("(define a (+ 1 b))");
h.eval_ok("(define b (+ 1 a))");
h.expect_error("(a1 a)", DiagnosticCategory::Runtime,
"recursive");
}
}
// ============================================================================
// Span Accuracy Tests
// ============================================================================
TEST_CASE("Diagnostics: span points at the correct subexpression",
"[golden][signal_engine][diagnostics][span]") {
SECTION("bare unknown symbol span") {
GoldenHarness h;
h.eval_ok("(define freq 440)");
// "(a1 frq)" — 'frq' starts at offset 4, length 3
h.expect_error_at("(a1 frq)",
DiagnosticCategory::UndefinedName,
4, 3, "freq");
}
SECTION("nested unknown symbol span") {
GoldenHarness h;
// "(a1 (+ 1 (sni beat)))"
// 0123456789...
// 'sni' starts at offset 10, length 3
h.expect_error_at("(a1 (+ 1 (sni beat)))",
DiagnosticCategory::UndefinedName,
10, 3, "sin");
}
SECTION("define inside output span points at define") {
GoldenHarness h;
// "(a1 (define x 1))" — 'define' starts at offset 5, length 6
h.expect_error_at("(a1 (define x 1))",
DiagnosticCategory::Boundary,
5, 6, "inside an output");
}
SECTION("unknown function in call position span") {
GoldenHarness h;
// "(a1 (blorg 1))" — 'blorg' starts at offset 5, length 5
h.expect_error_at("(a1 (blorg 1))",
DiagnosticCategory::UndefinedName,
5, 5);
}
}
// ============================================================================
// Fuzzy Matching Quality Tests
// ============================================================================
TEST_CASE("Diagnostics: fuzzy match quality",
"[golden][signal_engine][diagnostics][fuzzy]") {
SECTION("distance 1 transposition: sni -> sin") {
GoldenHarness h;
h.expect_error("(a1 (sni beat))", DiagnosticCategory::UndefinedName,
"sin", "sin");
}
SECTION("distance 1 substitution: beet -> beat") {
GoldenHarness h;
h.expect_error("(a1 beet)", DiagnosticCategory::UndefinedName,
"beat", "beat");
}
SECTION("user-defined symbol fuzzy match: frq -> freq") {
GoldenHarness h;
h.eval_ok("(define freq 440)");
h.expect_error("(a1 frq)", DiagnosticCategory::UndefinedName,
"freq", "freq");
}
SECTION("no match for very different name — still UndefinedName") {
GoldenHarness h;
h.expect_error("(a1 zzzzzzz)", DiagnosticCategory::UndefinedName);
}
SECTION("function name fuzzy match in call position") {
GoldenHarness h;
// Should suggest 'sin' when 'sni' is used as a function
EvalResult r = h.eval_result("(a1 (sni beat))");
REQUIRE(r.kind == EvalResult::Error);
REQUIRE(r.diagnostic_count > 0);
bool found_suggestion = false;
for (uint8_t i = 0; i < r.diagnostic_count; ++i) {
if (r.diagnostics[i].category == DiagnosticCategory::UndefinedName &&
r.diagnostics[i].suggestion != nullptr) {
found_suggestion = true;
REQUIRE(std::string(r.diagnostics[i].suggestion).find("sin")
!= std::string::npos);
}
}
REQUIRE(found_suggestion);
}
}
// ============================================================================
// Message Plainness Tests — no jargon
// ============================================================================
TEST_CASE("Diagnostics: messages use plain language",
"[golden][signal_engine][diagnostics][language]") {
SECTION("arity error says 'Wrong number' not 'arity mismatch'") {
GoldenHarness h;
h.eval_ok("(defn f [x] (* x 2))");
EvalResult r = h.eval_result("(a1 (f 1 2))");
REQUIRE(r.kind == EvalResult::Error);
REQUIRE(r.diagnostic_count > 0);
std::string msg = r.diagnostics[0].message ? r.diagnostics[0].message : "";
// Must not contain jargon
REQUIRE(msg.find("arity") == std::string::npos);
REQUIRE(msg.find("predicate") == std::string::npos);
REQUIRE(msg.find("lvalue") == std::string::npos);
}
SECTION("boundary error uses plain language") {
GoldenHarness h;
EvalResult r = h.eval_result("(a1 (define x 1))");
REQUIRE(r.kind == EvalResult::Error);
REQUIRE(r.diagnostic_count > 0);
std::string msg = r.diagnostics[0].message ? r.diagnostics[0].message : "";
REQUIRE(msg.find("side-effect") == std::string::npos);
REQUIRE(msg.find("boundary violation") == std::string::npos);
}
SECTION("unknown name error uses plain language") {
GoldenHarness h;
EvalResult r = h.eval_result("(a1 nonexistent)");
REQUIRE(r.kind == EvalResult::Error);
REQUIRE(r.diagnostic_count > 0);
std::string msg = r.diagnostics[0].message ? r.diagnostics[0].message : "";
REQUIRE(msg.find("undefined variable") == std::string::npos);
REQUIRE(msg.find("unbound") == std::string::npos);
}
}
// ============================================================================
// Suggestion Validity Meta-Tests
// ============================================================================
TEST_CASE("Diagnostics: suggestions compile successfully",
"[golden][signal_engine][diagnostics][suggestion]") {
SECTION("boundary error suggestion compiles") {
GoldenHarness h;
// The suggestion for define-inside-output is "Use it at the top level instead"
// which is advice, not code — verify it's present
EvalResult r = h.eval_result("(a1 (define x 1))");
REQUIRE(r.kind == EvalResult::Error);
REQUIRE(r.diagnostic_count > 0);
REQUIRE(r.diagnostics[0].suggestion != nullptr);
}
SECTION("fuzzy match suggestion compiles") {
GoldenHarness h;
h.eval_ok("(define freq 440)");
h.expect_suggestion_compiles("(a1 frq)", DiagnosticCategory::UndefinedName);
}
SECTION("lambda boundary suggestion is actionable") {
GoldenHarness h;
EvalResult r = h.eval_result("(a1 (fn [x] x))");
REQUIRE(r.kind == EvalResult::Error);
REQUIRE(r.diagnostic_count > 0);
REQUIRE(r.diagnostics[0].suggestion != nullptr);
std::string sug = r.diagnostics[0].suggestion;
// Should mention 'defn'
REQUIRE(sug.find("defn") != std::string::npos);
}
SECTION("syntax error suggestion is present") {
GoldenHarness h;
EvalResult r = h.eval_result("(a1 (123 beat))");
REQUIRE(r.kind == EvalResult::Error);
REQUIRE(r.diagnostic_count > 0);
REQUIRE(r.diagnostics[0].suggestion != nullptr);
}
}
// ============================================================================
// Multiple Diagnostics (recoverable errors)
// ============================================================================
TEST_CASE("Diagnostics: error leaves previous output intact",
"[golden][signal_engine][diagnostics][isolation]") {
SECTION("compile error preserves last known good output") {
GoldenHarness h;
h.assign_ok("a1", "(+ beat 1)");
REQUIRE(h.sample("a1", 0.25) == Approx(1.5));
EvalResult bad = h.eval_result("(a1 (unknown-name beat))");
REQUIRE(bad.kind == EvalResult::Error);
REQUIRE(bad.diagnostic_count > 0);
REQUIRE(bad.diagnostics[0].category == DiagnosticCategory::UndefinedName);
// Previous output still runs
REQUIRE(h.sample("a1", 0.25) == Approx(1.5));
}
SECTION("one output error does not affect another output") {
GoldenHarness h;
h.assign_ok("a1", "0.2");
h.assign_ok("a2", "0.8");
EvalResult bad = h.eval_result("(a1 (not-a-function 1))");
REQUIRE(bad.kind == EvalResult::Error);
REQUIRE(bad.diagnostics[0].category == DiagnosticCategory::UndefinedName);
REQUIRE(h.sample("a1", 0.0) == Approx(0.2));
REQUIRE(h.sample("a2", 0.0) == Approx(0.8));
}
}
// ============================================================================
// Comprehensive Category Coverage Audit
// ============================================================================
TEST_CASE("Diagnostics: every category has at least one strict test",
"[golden][signal_engine][diagnostics][coverage]") {
SECTION("Syntax category coverage") {
GoldenHarness h;
// Non-symbol after open paren
h.expect_error("(a1 (123 beat))", DiagnosticCategory::Syntax);
}
SECTION("UndefinedName category coverage") {
GoldenHarness h;
h.expect_error("(a1 nonexistent)", DiagnosticCategory::UndefinedName);
}
SECTION("Arity category coverage") {
GoldenHarness h;
h.eval_ok("(defn f [x] x)");
h.expect_error("(a1 (f 1 2))", DiagnosticCategory::Arity);
}
SECTION("Type category coverage") {
GoldenHarness h;
// prev with non-output argument
h.expect_error("(a1 (prev beat))", DiagnosticCategory::Type);
}
SECTION("Boundary category coverage") {
GoldenHarness h;
h.expect_error("(a1 (define x 1))", DiagnosticCategory::Boundary);
}
SECTION("Runtime category coverage") {
GoldenHarness h;
h.eval_ok("(defn g [x] (g x))");
h.expect_error("(a1 (g 1))", DiagnosticCategory::Runtime);
}
}
// ============================================================================
// Phase 5: Stateful Compiler Surface — defstate and integrate
// ============================================================================
TEST_CASE("State: defstate creates a cell with initial value and update body",
"[golden][signal_engine][state]") {
SECTION("defstate counter increments each tick") {
GoldenHarness h;
h.eval_ok("(defstate counter 0 (+ counter 1))");
h.assign_ok("a1", "counter");
// First tick: counter should be 0 (initial value read before update)
REQUIRE(h.tick("a1", 0.0) == Approx(0.0));
// After first tick, counter updates to 0+1=1
REQUIRE(h.tick("a1", 0.001) == Approx(1.0));
REQUIRE(h.tick("a1", 0.002) == Approx(2.0));
REQUIRE(h.tick("a1", 0.003) == Approx(3.0));
}
SECTION("defstate with dt-based accumulation") {
GoldenHarness h;
h.eval_ok("(defstate accum 0 (+ accum dt))");
h.assign_ok("a1", "accum");
// First tick at t=0: accum=0
REQUIRE(h.tick("a1", 0.0) == Approx(0.0));
// dt = 0.001 - 0.0 = 0.001, accum = 0 + 0.001
REQUIRE(h.tick("a1", 0.001) == Approx(0.001));
// dt = 0.002 - 0.001 = 0.001, accum = 0.001 + 0.001
REQUIRE(h.tick("a1", 0.002) == Approx(0.002));
}
SECTION("defstate update body can reference cells") {
GoldenHarness h;
h.eval_ok("(define rate 10)");
h.eval_ok("(defstate accum 0 (+ accum (* rate dt)))");
h.assign_ok("a1", "accum");
// accum grows at rate=10 per second
REQUIRE(h.tick("a1", 0.0) == Approx(0.0));
// dt=0.001, accum = 0 + 10*0.001 = 0.01
REQUIRE(h.tick("a1", 0.001) == Approx(0.01));
// dt=0.001, accum = 0.01 + 10*0.001 = 0.02
REQUIRE(h.tick("a1", 0.002) == Approx(0.02));
}
SECTION("defstate value persists across cell redefinition") {
GoldenHarness h;
h.eval_ok("(define rate 1)");
h.eval_ok("(defstate phase 0 (+ phase (* rate dt)))");
h.assign_ok("a1", "phase");
// Tick a few times at rate=1
REQUIRE(h.tick("a1", 0.0) == Approx(0.0));
REQUIRE(h.tick("a1", 0.001) == Approx(0.001));
REQUIRE(h.tick("a1", 0.002) == Approx(0.002));
double before = 0.002;
// Redefine rate — phase's state should NOT reset
h.eval_ok("(define rate 2)");
// dt=0.001, phase = 0.002 + 2*0.001 = 0.004
REQUIRE(h.tick("a1", 0.003) == Approx(before + 2.0 * 0.001));
}
SECTION("defstate with non-zero initial value") {
GoldenHarness h;
h.eval_ok("(defstate x 100 (+ x 1))");
h.assign_ok("a1", "x");
REQUIRE(h.tick("a1", 0.0) == Approx(100.0));
REQUIRE(h.tick("a1", 0.001) == Approx(101.0));
REQUIRE(h.tick("a1", 0.002) == Approx(102.0));
}
SECTION("multiple defstate cells are independent") {
GoldenHarness h;
h.eval_ok("(defstate a 0 (+ a 1))");
h.eval_ok("(defstate b 10 (+ b 2))");
h.assign_ok("a1", "a");
h.assign_ok("a2", "b");
REQUIRE(h.tick("a1", 0.0) == Approx(0.0));
REQUIRE(h.tick("a2", 0.0) == Approx(10.0)); // same tick via harness
REQUIRE(h.tick("a1", 0.001) == Approx(1.0));
REQUIRE(h.tick("a2", 0.001) == Approx(12.0));
}
SECTION("defstate inside output expression is rejected") {
GoldenHarness h;
h.expect_error("(a1 (defstate x 0 (+ x 1)))",
DiagnosticCategory::Boundary);
}
}
TEST_CASE("State: integrate accumulates rate over time",
"[golden][signal_engine][state]") {
SECTION("integrate constant rate approximates linear ramp") {
GoldenHarness h;
h.assign_ok("a1", "(integrate 1.0)");
// integrate(1.0) = state += 1.0 * dt per tick
REQUIRE(h.tick("a1", 0.0) == Approx(0.0));
double dt = 0.001;
REQUIRE(h.tick("a1", dt) == Approx(dt));
REQUIRE(h.tick("a1", 2*dt) == Approx(2*dt));
REQUIRE(h.tick("a1", 3*dt) == Approx(3*dt));
}
SECTION("integrate with rate from cell") {
GoldenHarness h;
h.eval_ok("(define rate 5.0)");
h.assign_ok("a1", "(integrate rate)");
// state += 5.0 * dt per tick
REQUIRE(h.tick("a1", 0.0) == Approx(0.0));
double dt = 0.001;
REQUIRE(h.tick("a1", dt) == Approx(5.0 * dt));
REQUIRE(h.tick("a1", 2*dt) == Approx(2 * 5.0 * dt));
}
SECTION("integrate with time-varying rate") {
GoldenHarness h;
h.assign_ok("a1", "(integrate t)");
// state += t * dt per tick (t changes)
REQUIRE(h.tick("a1", 0.0) == Approx(0.0));
// dt=0.001, state = 0 + 0.001 * 0.001 = 0.000001
REQUIRE(h.tick("a1", 0.001) == Approx(0.001 * 0.001));
}
SECTION("multiple independent integrates in same output") {
GoldenHarness h;
h.assign_ok("a1", "(+ (integrate 1.0) (integrate 2.0))");
// Two separate state slots, summed
REQUIRE(h.tick("a1", 0.0) == Approx(0.0));
double dt = 0.001;
REQUIRE(h.tick("a1", dt) == Approx(3.0 * dt));
REQUIRE(h.tick("a1", 2*dt) == Approx(2 * 3.0 * dt));
}
}
// ── Top-level expression eval (scratch isolation) ──────────────────────────
TEST_CASE("Golden: top-level bar returns value at injected time",
"[golden][scratch_eval]") {
GoldenHarness h;
// At 120 BPM, beat period = 0.5s. bar = fmod(t * bpm/60, 1) at t=0.125
// beat = fmod(0.125 * 2, 1) = 0.25
h.engine.state.current_time = 0.125;
h.engine.state.current_dt = 0.0;
EvalResult r = h.eval_result("bar");
REQUIRE(r.kind == EvalResult::Number);
// bar = fmod(t * bpm / 60 / beats_per_bar, 1.0) = fmod(0.125*120/60/4, 1) = fmod(0.0625, 1) = 0.0625
REQUIRE(r.number == Approx(0.0625).margin(1e-9));
}
TEST_CASE("Golden: top-level (* bar 0.5) returns number",
"[golden][scratch_eval]") {
GoldenHarness h;
h.engine.state.current_time = 0.0;
EvalResult r = h.eval_result("(* bar 0.5)");
REQUIRE(r.kind == EvalResult::Number);
// At t=0, bar = 0, so (* 0 0.5) = 0
REQUIRE(r.number == Approx(0.0));
}
TEST_CASE("Golden: top-level eval-at-time returns number",
"[golden][scratch_eval]") {
GoldenHarness h;
h.engine.state.current_time = 0.0;
EvalResult r = h.eval_result("(eval-at-time 0.5 bar)");
REQUIRE(r.kind == EvalResult::Number);
// eval-at-time 0.5 bar: bar at t=0.5 at 120bpm 4/4 = fmod(0.5*120/60/4, 1) = fmod(0.25, 1) = 0.25
REQUIRE(r.number == Approx(0.25).margin(1e-9));
}
TEST_CASE("Golden: top-level vector returns text with samples",
"[golden][scratch_eval]") {
GoldenHarness h;
h.engine.state.current_time = 0.0;
EvalResult r = h.eval_result("[(eval-at-time 0 bar) (eval-at-time 0.5 bar)]");
REQUIRE(r.kind == EvalResult::Text);
// Should contain [0 0.25] or similar
REQUIRE(r.text != nullptr);
REQUIRE(r.text_length > 0);
std::string text(r.text, r.text_length);
REQUIRE(text[0] == '[');
REQUIRE(text[text.size()-1] == ']');
}
TEST_CASE("Golden: repeated top-level eval doesn't grow live node pool",
"[golden][scratch_eval]") {
GoldenHarness h;
h.engine.state.current_time = 0.0;
uint16_t initial_count = h.engine.pool.node_count;
for (int i = 0; i < 10; i++) {
EvalResult r = h.eval_result("(* bar 0.5)");
REQUIRE(r.kind == EvalResult::Number);
}
REQUIRE(h.engine.pool.node_count == initial_count);
}
TEST_CASE("Golden: repeated top-level vector eval doesn't grow live data tables",
"[golden][scratch_eval]") {
GoldenHarness h;
h.engine.state.current_time = 0.0;
uint8_t initial_tables = h.engine.cells.data_table_count;
for (int i = 0; i < 5; i++) {
EvalResult r = h.eval_result("[(eval-at-time 0 bar) (eval-at-time 0.5 bar)]");
REQUIRE(r.kind == EvalResult::Text);
}
REQUIRE(h.engine.cells.data_table_count == initial_tables);
}
TEST_CASE("Golden: invalid top-level signal expression returns error",
"[golden][scratch_eval]") {
GoldenHarness h;
EvalResult r = h.eval_result("(nonexistent-function bar)");
REQUIRE(r.kind == EvalResult::Error);
REQUIRE(r.diagnostic_count > 0);
}
TEST_CASE("Golden: defined cell visible in top-level expression",
"[golden][scratch_eval]") {
GoldenHarness h;
h.eval_ok("(define freq 440)");
h.engine.state.current_time = 0.0;
EvalResult r = h.eval_result("(* freq 2)");
REQUIRE(r.kind == EvalResult::Number);
REQUIRE(r.number == Approx(880.0));
}
// ── State Resource Registry ─────────────────────────────────────────────────
TEST_CASE("Registry: resolve allocates new slot on first call",
"[golden][registry]") {
StateResourceRegistry reg;
double state_values[MAX_STATE_SLOTS] = {};
uint16_t slot_count = 0;
StateResourceKey key = { internSymbol("phase-A"), ResourceKind::OscillatorPhase, 0 };
uint16_t slot = reg.resolve(key, 0.0, state_values, slot_count);
REQUIRE(slot == 0);
REQUIRE(slot_count == 1);
REQUIRE(reg.entry_count == 1);
REQUIRE(state_values[0] == 0.0);
}
TEST_CASE("Registry: resolve returns existing slot for matching key",
"[golden][registry]") {
StateResourceRegistry reg;
double state_values[MAX_STATE_SLOTS] = {};
uint16_t slot_count = 0;
StateResourceKey key = { internSymbol("phase-A"), ResourceKind::OscillatorPhase, 0 };
uint16_t slot1 = reg.resolve(key, 0.0, state_values, slot_count);
state_values[slot1] = 0.75;
uint16_t slot2 = reg.resolve(key, 0.0, state_values, slot_count);
REQUIRE(slot2 == slot1);
REQUIRE(slot_count == 1);
REQUIRE(state_values[slot2] == 0.75);
}
TEST_CASE("Registry: different keys get different slots",
"[golden][registry]") {
StateResourceRegistry reg;
double state_values[MAX_STATE_SLOTS] = {};
uint16_t slot_count = 0;
StateResourceKey k1 = { internSymbol("A"), ResourceKind::OscillatorPhase, 0 };
StateResourceKey k2 = { internSymbol("B"), ResourceKind::OscillatorPhase, 0 };
StateResourceKey k3 = { internSymbol("A"), ResourceKind::TriggerMemory, 0 };
uint16_t s1 = reg.resolve(k1, 0.0, state_values, slot_count);
uint16_t s2 = reg.resolve(k2, 0.0, state_values, slot_count);
uint16_t s3 = reg.resolve(k3, 1.0, state_values, slot_count);
REQUIRE(s1 != s2);
REQUIRE(s1 != s3);
REQUIRE(s2 != s3);
REQUIRE(slot_count == 3);
REQUIRE(state_values[s3] == 1.0);
}
TEST_CASE("Registry: mark_all_inactive and re-resolve reactivates",
"[golden][registry]") {
StateResourceRegistry reg;
double state_values[MAX_STATE_SLOTS] = {};
uint16_t slot_count = 0;
StateResourceKey key = { internSymbol("X"), ResourceKind::Integrator, 0 };
reg.resolve(key, 0.0, state_values, slot_count);
REQUIRE(reg.entries[0].active == true);
reg.mark_all_inactive();
REQUIRE(reg.entries[0].active == false);
reg.resolve(key, 0.0, state_values, slot_count);
REQUIRE(reg.entries[0].active == true);
REQUIRE(slot_count == 1);
}
TEST_CASE("Registry: clear resets completely",
"[golden][registry]") {
StateResourceRegistry reg;
double state_values[MAX_STATE_SLOTS] = {};
uint16_t slot_count = 0;
StateResourceKey key = { internSymbol("Y"), ResourceKind::SlewAccumulator, 0 };
reg.resolve(key, 0.5, state_values, slot_count);
REQUIRE(reg.entry_count == 1);
reg.clear();
REQUIRE(reg.entry_count == 0);
}
TEST_CASE("Golden: repeated set with expression doesn't grow live pool",
"[golden][scratch_eval]") {
GoldenHarness h;
h.eval_ok("(define x 1)");
uint16_t initial_nodes = h.engine.pool.node_count;
for (int i = 0; i < 10; i++) {
h.eval_ok("(set x (+ 1 2))");
}
REQUIRE(h.engine.pool.node_count == initial_nodes);
EvalResult r = h.eval_result("x");
REQUIRE(r.kind == EvalResult::Number);
REQUIRE(r.number == Approx(3.0));
}
Reference in a new issue Copy permalink