dspx 0.1.1-alpha.0

package/src/ts/__tests__/ChebyshevBiquad.test.ts

@@ -0,0 +1,229 @@
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+import { IirFilter } from "../filters.js";
+
+const sampleRate = 44100;
+
+describe("Chebyshev Filters", () => {
+  test("should create Chebyshev low-pass filter", async () => {
+    const filter = IirFilter.createChebyshevLowPass({
+      cutoffFrequency: 1000,
+      sampleRate,
+      order: 2,
+      rippleDb: 0.5,
+    });
+
+    assert.strictEqual(filter.getBCoefficients().length, 3);
+    assert.strictEqual(filter.getACoefficients().length, 2);
+
+    // Test filtering
+    const testSignal = new Float32Array(10).fill(1.0);
+    const filtered = await filter.process(testSignal);
+    assert.strictEqual(filtered.length, 10);
+  });
+
+  test("should create Chebyshev high-pass filter", async () => {
+    const filter = IirFilter.createChebyshevHighPass({
+      cutoffFrequency: 500,
+      sampleRate,
+      order: 2,
+      rippleDb: 0.5,
+    });
+
+    const testSignal = new Float32Array(10).fill(1.0);
+    const filtered = await filter.process(testSignal);
+    assert.strictEqual(filtered.length, 10);
+  });
+
+  test("should create Chebyshev band-pass filter", async () => {
+    const filter = IirFilter.createChebyshevBandPass({
+      lowCutoffFrequency: 500,
+      highCutoffFrequency: 2000,
+      sampleRate,
+      order: 2,
+      rippleDb: 0.5,
+    });
+
+    assert.strictEqual(filter.getBCoefficients().length, 3);
+
+    const testSignal = new Float32Array(10).fill(1.0);
+    await filter.process(testSignal);
+  });
+
+  test("should use default ripple of 0.5 dB", () => {
+    const filter1 = IirFilter.createChebyshevLowPass({
+      cutoffFrequency: 1000,
+      sampleRate,
+      order: 2,
+    });
+
+    const filter2 = IirFilter.createChebyshevLowPass({
+      cutoffFrequency: 1000,
+      sampleRate,
+      order: 2,
+      rippleDb: 0.5,
+    });
+
+    const bCoeffs1 = filter1.getBCoefficients();
+    const bCoeffs2 = filter2.getBCoefficients();
+
+    // Coefficients should be equal for same ripple
+    assert.strictEqual(bCoeffs1.length, bCoeffs2.length);
+  });
+
+  test("should support different ripple values", () => {
+    const filter1 = IirFilter.createChebyshevLowPass({
+      cutoffFrequency: 1000,
+      sampleRate,
+      order: 2,
+      rippleDb: 0.1,
+    });
+
+    const filter2 = IirFilter.createChebyshevLowPass({
+      cutoffFrequency: 1000,
+      sampleRate,
+      order: 2,
+      rippleDb: 1.0,
+    });
+
+    const bCoeffs1 = filter1.getBCoefficients();
+    const bCoeffs2 = filter2.getBCoefficients();
+
+    // Both should have coefficients
+    assert.strictEqual(bCoeffs1.length, 3);
+    assert.strictEqual(bCoeffs2.length, 3);
+  });
+});
+
+describe("Biquad EQ Filters", () => {
+  test("should create peaking EQ filter with boost", async () => {
+    const filter = IirFilter.createPeakingEQ({
+      centerFrequency: 1000,
+      sampleRate,
+      Q: 2.0,
+      gainDb: 6.0,
+    });
+
+    const bCoeffs = filter.getBCoefficients();
+    const aCoeffs = filter.getACoefficients();
+
+    assert.strictEqual(bCoeffs.length, 3);
+    assert.strictEqual(aCoeffs.length, 2);
+
+    // Test basic processing
+    const testSignal = new Float32Array(20).fill(1.0);
+    const boosted = await filter.process(testSignal);
+    assert.strictEqual(boosted.length, 20);
+  });
+
+  test("should create low-shelf filter", async () => {
+    const filter = IirFilter.createLowShelf({
+      cutoffFrequency: 1000,
+      sampleRate,
+      gainDb: 6.0,
+      Q: 0.707,
+    });
+
+    const testSignal = new Float32Array(10).fill(1.0);
+    const processed = await filter.process(testSignal);
+
+    assert.strictEqual(processed.length, 10);
+  });
+
+  test("should create high-shelf filter with attenuation", async () => {
+    const filter = IirFilter.createHighShelf({
+      cutoffFrequency: 1000,
+      sampleRate,
+      gainDb: -6.0,
+      Q: 0.707,
+    });
+
+    const testSignal = new Float32Array(20).fill(1.0);
+    const attenuated = await filter.process(testSignal);
+
+    assert.strictEqual(attenuated.length, 20);
+  });
+
+  test("should support EQ chain", async () => {
+    // Create 3-band parametric EQ
+    const lowShelf = IirFilter.createLowShelf({
+      cutoffFrequency: 200,
+      sampleRate,
+      gainDb: 3.0,
+      Q: 0.707,
+    });
+
+    const midPeak = IirFilter.createPeakingEQ({
+      centerFrequency: 1000,
+      sampleRate,
+      Q: 1.5,
+      gainDb: -6.0,
+    });
+
+    const highShelf = IirFilter.createHighShelf({
+      cutoffFrequency: 3000,
+      sampleRate,
+      gainDb: 2.0,
+      Q: 0.707,
+    });
+
+    // Test signal
+    const testSignal = new Float32Array(100).fill(1.0);
+
+    // Apply EQ chain
+    let processed = await lowShelf.process(testSignal);
+    processed = await midPeak.process(processed);
+    processed = await highShelf.process(processed);
+
+    assert.strictEqual(processed.length, 100);
+  });
+
+  test("should create peaking EQ with negative gain (cut)", async () => {
+    const filter = IirFilter.createPeakingEQ({
+      centerFrequency: 1000,
+      sampleRate,
+      Q: 2.0,
+      gainDb: -12.0,
+    });
+
+    const testSignal = new Float32Array(20).fill(1.0);
+    const cut = await filter.process(testSignal);
+
+    assert.strictEqual(cut.length, 20);
+  });
+});
+
+describe("Filter Validation", () => {
+  test("should reject ripple > 3 dB", () => {
+    assert.throws(() => {
+      IirFilter.createChebyshevLowPass({
+        cutoffFrequency: 1000,
+        sampleRate,
+        order: 2,
+        rippleDb: 5.0,
+      });
+    }, /ripple/i);
+  });
+
+  test("should reject Q = 0 for peaking EQ", () => {
+    assert.throws(() => {
+      IirFilter.createPeakingEQ({
+        centerFrequency: 1000,
+        sampleRate,
+        Q: 0,
+        gainDb: 6.0,
+      });
+    }, /Q must be positive/i);
+  });
+
+  test("should reject negative Q", () => {
+    assert.throws(() => {
+      IirFilter.createPeakingEQ({
+        centerFrequency: 1000,
+        sampleRate,
+        Q: -1.5,
+        gainDb: 6.0,
+      });
+    }, /Q must be positive/i);
+  });
+});

package/src/ts/__tests__/CircularLogBuffer.test.ts

@@ -0,0 +1,158 @@
+/**
+ * Unit tests for CircularLogBuffer
+ */
+
+import { describe, it } from "node:test";
+import assert from "node:assert";
+import { CircularLogBuffer } from "../CircularLogBuffer.js";
+import type { LogEntry } from "../types.js";
+
+describe("CircularLogBuffer", () => {
+  it("should start empty", () => {
+    const buffer = new CircularLogBuffer(4);
+    assert.strictEqual(buffer.size(), 0);
+    assert.strictEqual(buffer.hasEntries(), false);
+    assert.deepStrictEqual(buffer.flush(), []);
+  });
+
+  it("should store and retrieve entries in order", () => {
+    const buffer = new CircularLogBuffer(4);
+
+    const entry1: LogEntry = {
+      level: "info",
+      message: "First",
+      timestamp: 1,
+    };
+    const entry2: LogEntry = {
+      level: "debug",
+      message: "Second",
+      timestamp: 2,
+    };
+
+    buffer.push(entry1);
+    buffer.push(entry2);
+
+    assert.strictEqual(buffer.size(), 2);
+    assert.strictEqual(buffer.hasEntries(), true);
+
+    const entries = buffer.flush();
+    assert.strictEqual(entries.length, 2);
+    assert.strictEqual(entries[0].message, "First");
+    assert.strictEqual(entries[1].message, "Second");
+
+    // Should be empty after flush
+    assert.strictEqual(buffer.size(), 0);
+    assert.strictEqual(buffer.hasEntries(), false);
+  });
+
+  it("should overwrite oldest entries when full", () => {
+    const buffer = new CircularLogBuffer(3);
+
+    buffer.push({ level: "info", message: "1", timestamp: 1 });
+    buffer.push({ level: "info", message: "2", timestamp: 2 });
+    buffer.push({ level: "info", message: "3", timestamp: 3 });
+    buffer.push({ level: "info", message: "4", timestamp: 4 }); // Overwrites "1"
+    buffer.push({ level: "info", message: "5", timestamp: 5 }); // Overwrites "2"
+
+    const entries = buffer.flush();
+    assert.strictEqual(entries.length, 3);
+    assert.strictEqual(entries[0].message, "3"); // Oldest
+    assert.strictEqual(entries[1].message, "4");
+    assert.strictEqual(entries[2].message, "5"); // Newest
+  });
+
+  it("should handle wrap-around correctly", () => {
+    const buffer = new CircularLogBuffer(4);
+
+    // Fill buffer
+    buffer.push({ level: "info", message: "A", timestamp: 1 });
+    buffer.push({ level: "info", message: "B", timestamp: 2 });
+    buffer.push({ level: "info", message: "C", timestamp: 3 });
+    buffer.push({ level: "info", message: "D", timestamp: 4 });
+
+    // Flush and refill
+    buffer.flush();
+
+    buffer.push({ level: "info", message: "E", timestamp: 5 });
+    buffer.push({ level: "info", message: "F", timestamp: 6 });
+
+    const entries = buffer.flush();
+    assert.strictEqual(entries.length, 2);
+    assert.strictEqual(entries[0].message, "E");
+    assert.strictEqual(entries[1].message, "F");
+  });
+
+  it("should clear without allocating new memory", () => {
+    const buffer = new CircularLogBuffer(4);
+
+    buffer.push({ level: "info", message: "Test", timestamp: 1 });
+    buffer.push({ level: "info", message: "Test", timestamp: 2 });
+
+    assert.strictEqual(buffer.size(), 2);
+
+    buffer.clear();
+
+    assert.strictEqual(buffer.size(), 0);
+    assert.strictEqual(buffer.hasEntries(), false);
+    assert.deepStrictEqual(buffer.flush(), []);
+  });
+
+  it("should handle context in log entries", () => {
+    const buffer = new CircularLogBuffer(4);
+
+    buffer.push({
+      level: "error",
+      message: "Error occurred",
+      context: { code: 500, path: "/api/test" },
+      timestamp: 123,
+    });
+
+    const entries = buffer.flush();
+    assert.strictEqual(entries[0].context?.code, 500);
+    assert.strictEqual(entries[0].context?.path, "/api/test");
+  });
+
+  it("should maintain chronological order when full", () => {
+    const buffer = new CircularLogBuffer(5);
+
+    // Add 10 entries (buffer capacity is 5)
+    for (let i = 1; i <= 10; i++) {
+      buffer.push({
+        level: "info",
+        message: `Entry ${i}`,
+        timestamp: i,
+      });
+    }
+
+    const entries = buffer.flush();
+    assert.strictEqual(entries.length, 5);
+
+    // Should have entries 6-10 (oldest to newest)
+    assert.strictEqual(entries[0].message, "Entry 6");
+    assert.strictEqual(entries[1].message, "Entry 7");
+    assert.strictEqual(entries[2].message, "Entry 8");
+    assert.strictEqual(entries[3].message, "Entry 9");
+    assert.strictEqual(entries[4].message, "Entry 10");
+  });
+
+  it("should support multiple flush cycles", () => {
+    const buffer = new CircularLogBuffer(3);
+
+    // Cycle 1
+    buffer.push({ level: "info", message: "A", timestamp: 1 });
+    buffer.push({ level: "info", message: "B", timestamp: 2 });
+    let entries = buffer.flush();
+    assert.strictEqual(entries.length, 2);
+    assert.strictEqual(entries[0].message, "A");
+
+    // Cycle 2
+    buffer.push({ level: "info", message: "C", timestamp: 3 });
+    entries = buffer.flush();
+    assert.strictEqual(entries.length, 1);
+    assert.strictEqual(entries[0].message, "C");
+
+    // Cycle 3 (empty)
+    entries = buffer.flush();
+    assert.strictEqual(entries.length, 0);
+  });
+});