web-a2e 1.0.0

package/tests/unit/test_audio.cpp

@@ -0,0 +1,196 @@
+/*
+ * test_audio.cpp - Unit tests for Audio (speaker) emulation
+ */
+
+#define CATCH_CONFIG_MAIN
+#include "catch.hpp"
+
+#include "audio.hpp"
+
+#include <cmath>
+#include <vector>
+
+using namespace a2e;
+
+// ============================================================================
+// Constructor
+// ============================================================================
+
+TEST_CASE("Audio constructor creates a valid instance", "[audio][ctor]") {
+    Audio audio;
+    // Default state: speaker off, volume 0.5, not muted
+    CHECK(audio.getSpeakerState() == false);
+    CHECK(audio.getVolume() == Approx(0.5f));
+    CHECK(audio.isMuted() == false);
+}
+
+// ============================================================================
+// toggleSpeaker
+// ============================================================================
+
+TEST_CASE("toggleSpeaker records events and state updates on sample generation", "[audio][toggle]") {
+    Audio audio;
+    CHECK(audio.getSpeakerState() == false);
+
+    // toggleSpeaker only records toggle events; it does NOT immediately
+    // change speakerState_. The state is updated when generateStereoSamples
+    // processes the recorded toggle events.
+    audio.toggleSpeaker(100);
+
+    // State is still false until samples are generated
+    CHECK(audio.getSpeakerState() == false);
+
+    // Generate samples to process the toggle events
+    const int count = 128;
+    std::vector<float> buffer(count * 2, 0.0f);
+    audio.generateStereoSamples(buffer.data(), count, 10000);
+
+    // After generating samples with one toggle, speaker state should be true
+    CHECK(audio.getSpeakerState() == true);
+
+    // Toggle twice more and generate samples
+    audio.toggleSpeaker(11000);
+    audio.toggleSpeaker(12000);
+    audio.generateStereoSamples(buffer.data(), count, 20000);
+
+    // Two more toggles from true: true->false->true
+    CHECK(audio.getSpeakerState() == true);
+}
+
+// ============================================================================
+// generateStereoSamples
+// ============================================================================
+
+TEST_CASE("generateStereoSamples returns sample count", "[audio][generate]") {
+    Audio audio;
+    const int count = 128;
+    std::vector<float> buffer(count * 2, 0.0f); // stereo interleaved
+
+    int generated = audio.generateStereoSamples(buffer.data(), count, 10000);
+    CHECK(generated == count);
+}
+
+TEST_CASE("Silence: no toggles produces near-zero output", "[audio][silence]") {
+    Audio audio;
+    const int count = 256;
+    std::vector<float> buffer(count * 2, 1.0f); // Fill with non-zero
+
+    audio.generateStereoSamples(buffer.data(), count, 50000);
+
+    // After generating samples with no toggles, output should be near zero
+    float maxAbs = 0.0f;
+    for (int i = 0; i < count * 2; i++) {
+        float absVal = std::fabs(buffer[i]);
+        if (absVal > maxAbs) maxAbs = absVal;
+    }
+    // With DC removal and no toggles, output should settle toward zero
+    CHECK(maxAbs < 0.5f);
+}
+
+TEST_CASE("Toggle produces non-zero output", "[audio][toggle_output]") {
+    Audio audio;
+    audio.setVolume(1.0f);
+
+    // Toggle the speaker rapidly to create audio signal
+    for (int i = 0; i < 100; i++) {
+        audio.toggleSpeaker(i * 50);
+    }
+
+    const int count = 512;
+    std::vector<float> buffer(count * 2, 0.0f);
+    audio.generateStereoSamples(buffer.data(), count, 5100);
+
+    // Check there is at least some non-zero output
+    float maxAbs = 0.0f;
+    for (int i = 0; i < count * 2; i++) {
+        float absVal = std::fabs(buffer[i]);
+        if (absVal > maxAbs) maxAbs = absVal;
+    }
+    CHECK(maxAbs > 0.0f);
+}
+
+// ============================================================================
+// Volume control
+// ============================================================================
+
+TEST_CASE("setVolume/getVolume round-trips correctly", "[audio][volume]") {
+    Audio audio;
+
+    audio.setVolume(0.0f);
+    CHECK(audio.getVolume() == Approx(0.0f));
+
+    audio.setVolume(1.0f);
+    CHECK(audio.getVolume() == Approx(1.0f));
+
+    audio.setVolume(0.75f);
+    CHECK(audio.getVolume() == Approx(0.75f));
+}
+
+// ============================================================================
+// Mute control
+// ============================================================================
+
+TEST_CASE("setMuted/isMuted round-trips correctly", "[audio][mute]") {
+    Audio audio;
+
+    CHECK(audio.isMuted() == false);
+
+    audio.setMuted(true);
+    CHECK(audio.isMuted() == true);
+
+    audio.setMuted(false);
+    CHECK(audio.isMuted() == false);
+}
+
+TEST_CASE("Muted audio produces zero output", "[audio][mute_output]") {
+    Audio audio;
+    audio.setMuted(true);
+    audio.setVolume(1.0f);
+
+    // Generate toggles
+    for (int i = 0; i < 100; i++) {
+        audio.toggleSpeaker(i * 50);
+    }
+
+    const int count = 256;
+    std::vector<float> buffer(count * 2, 1.0f); // Fill with non-zero
+    audio.generateStereoSamples(buffer.data(), count, 5100);
+
+    // All samples should be zero when muted
+    for (int i = 0; i < count * 2; i++) {
+        CHECK(buffer[i] == Approx(0.0f));
+    }
+}
+
+// ============================================================================
+// reset
+// ============================================================================
+
+TEST_CASE("reset clears speaker state", "[audio][reset]") {
+    Audio audio;
+
+    // Toggle speaker and generate samples so state is updated
+    audio.toggleSpeaker(100);
+    const int count = 128;
+    std::vector<float> buffer(count * 2, 0.0f);
+    audio.generateStereoSamples(buffer.data(), count, 10000);
+    CHECK(audio.getSpeakerState() == true);
+
+    audio.reset();
+
+    CHECK(audio.getSpeakerState() == false);
+}
+
+TEST_CASE("reset preserves volume and mute settings", "[audio][reset]") {
+    Audio audio;
+
+    audio.setVolume(0.8f);
+    audio.setMuted(true);
+
+    audio.reset();
+
+    // Volume and mute are user settings, typically preserved across reset
+    // (though this depends on implementation; verify actual behavior)
+    // The speaker state itself should be reset
+    CHECK(audio.getSpeakerState() == false);
+}

package/tests/unit/test_ay8910.cpp

@@ -0,0 +1,311 @@
+/*
+ * test_ay8910.cpp - Unit tests for AY-3-8910 sound chip emulation
+ */
+
+#define CATCH_CONFIG_MAIN
+#include "catch.hpp"
+
+#include "ay8910.hpp"
+
+#include <vector>
+#include <cmath>
+
+using namespace a2e;
+
+// Helper: write a value to a register
+static void writeReg(AY8910& psg, uint8_t reg, uint8_t value) {
+    psg.setRegisterAddress(reg);
+    psg.writeRegister(value);
+}
+
+// Helper: read a register value
+static uint8_t readReg(AY8910& psg, uint8_t reg) {
+    psg.setRegisterAddress(reg);
+    return psg.readRegister();
+}
+
+// ============================================================================
+// Constructor
+// ============================================================================
+
+TEST_CASE("AY8910 constructor creates valid instance", "[ay8910][ctor]") {
+    AY8910 psg;
+    // Registers should be initialized to 0, except register 7 (mixer)
+    // which defaults to 0x3F (all tone and noise channels disabled for silence)
+    for (int r = 0; r < 16; r++) {
+        if (r == 7) {
+            CHECK(psg.getRegister(r) == 0x3F);
+        } else {
+            CHECK(psg.getRegister(r) == 0);
+        }
+    }
+}
+
+// ============================================================================
+// Register access cycle
+// ============================================================================
+
+TEST_CASE("setRegisterAddress/writeRegister/readRegister cycle", "[ay8910][reg]") {
+    AY8910 psg;
+
+    // Write to register 0 (Tone A fine)
+    psg.setRegisterAddress(0);
+    psg.writeRegister(0x5A);
+
+    // Read back
+    psg.setRegisterAddress(0);
+    uint8_t val = psg.readRegister();
+    CHECK(val == 0x5A);
+}
+
+// ============================================================================
+// Tone period registers (0-5)
+// ============================================================================
+
+TEST_CASE("Tone period registers write and read back", "[ay8910][tone]") {
+    AY8910 psg;
+
+    SECTION("Channel A tone period") {
+        writeReg(psg, 0, 0xAB); // Fine
+        writeReg(psg, 1, 0x0C); // Coarse (4-bit)
+        CHECK(readReg(psg, 0) == 0xAB);
+        CHECK(readReg(psg, 1) == 0x0C); // Only low 4 bits
+    }
+
+    SECTION("Channel B tone period") {
+        writeReg(psg, 2, 0x34);
+        writeReg(psg, 3, 0x05);
+        CHECK(readReg(psg, 2) == 0x34);
+        CHECK(readReg(psg, 3) == 0x05);
+    }
+
+    SECTION("Channel C tone period") {
+        writeReg(psg, 4, 0xFF);
+        writeReg(psg, 5, 0x0F);
+        CHECK(readReg(psg, 4) == 0xFF);
+        CHECK(readReg(psg, 5) == 0x0F);
+    }
+}
+
+// ============================================================================
+// Noise register (6) - 5 bit
+// ============================================================================
+
+TEST_CASE("Noise period register is 5-bit", "[ay8910][noise]") {
+    AY8910 psg;
+    writeReg(psg, 6, 0xFF);
+    // Only lower 5 bits should be stored
+    CHECK(readReg(psg, 6) == 0x1F);
+}
+
+TEST_CASE("Noise register write and read back", "[ay8910][noise]") {
+    AY8910 psg;
+    writeReg(psg, 6, 0x0A);
+    CHECK(readReg(psg, 6) == 0x0A);
+}
+
+// ============================================================================
+// Mixer register (7)
+// ============================================================================
+
+TEST_CASE("Mixer register controls tone/noise per channel", "[ay8910][mixer]") {
+    AY8910 psg;
+    // Bit layout: B7=IOB B6=IOA B5=NoiseC B4=NoiseB B3=NoiseA B2=ToneC B1=ToneB B0=ToneA
+    // 1 = disabled, 0 = enabled
+    writeReg(psg, 7, 0x38); // Disable all noise, enable all tone
+    CHECK(readReg(psg, 7) == 0x38);
+
+    writeReg(psg, 7, 0x3F); // Disable everything
+    CHECK(readReg(psg, 7) == 0x3F);
+
+    writeReg(psg, 7, 0x00); // Enable everything
+    CHECK(readReg(psg, 7) == 0x00);
+}
+
+// ============================================================================
+// Volume registers (8-10)
+// ============================================================================
+
+TEST_CASE("Volume registers write and read back", "[ay8910][volume]") {
+    AY8910 psg;
+
+    SECTION("Channel A volume") {
+        writeReg(psg, 8, 0x0F); // Max volume, no envelope
+        CHECK(readReg(psg, 8) == 0x0F);
+    }
+
+    SECTION("Channel B volume with envelope mode") {
+        writeReg(psg, 9, 0x10); // Bit 4 = use envelope
+        CHECK(readReg(psg, 9) == 0x10);
+    }
+
+    SECTION("Channel C volume") {
+        writeReg(psg, 10, 0x0A);
+        CHECK(readReg(psg, 10) == 0x0A);
+    }
+}
+
+// ============================================================================
+// Envelope registers (11-13)
+// ============================================================================
+
+TEST_CASE("Envelope period registers", "[ay8910][envelope]") {
+    AY8910 psg;
+
+    writeReg(psg, 11, 0xCD); // Envelope fine
+    writeReg(psg, 12, 0xAB); // Envelope coarse
+    CHECK(readReg(psg, 11) == 0xCD);
+    CHECK(readReg(psg, 12) == 0xAB);
+}
+
+TEST_CASE("Envelope shape register", "[ay8910][envelope]") {
+    AY8910 psg;
+
+    // 4-bit shape control
+    writeReg(psg, 13, 0x0E);
+    CHECK(readReg(psg, 13) == 0x0E);
+}
+
+// ============================================================================
+// reset
+// ============================================================================
+
+TEST_CASE("reset clears all registers", "[ay8910][reset]") {
+    AY8910 psg;
+
+    // Set various registers
+    writeReg(psg, 0, 0xFF);
+    writeReg(psg, 7, 0x00);
+    writeReg(psg, 8, 0x0F);
+    writeReg(psg, 13, 0x0E);
+
+    psg.reset();
+
+    for (int r = 0; r < 16; r++) {
+        INFO("Register " << r);
+        if (r == 7) {
+            // Mixer register resets to 0x3F (all channels disabled for silence)
+            CHECK(psg.getRegister(r) == 0x3F);
+        } else {
+            CHECK(psg.getRegister(r) == 0);
+        }
+    }
+}
+
+// ============================================================================
+// Channel muting
+// ============================================================================
+
+TEST_CASE("Channel muting defaults to unmuted", "[ay8910][mute]") {
+    AY8910 psg;
+    CHECK(psg.isChannelMuted(0) == false);
+    CHECK(psg.isChannelMuted(1) == false);
+    CHECK(psg.isChannelMuted(2) == false);
+}
+
+TEST_CASE("setChannelMute/isChannelMuted round-trips", "[ay8910][mute]") {
+    AY8910 psg;
+
+    psg.setChannelMute(0, true);
+    CHECK(psg.isChannelMuted(0) == true);
+    CHECK(psg.isChannelMuted(1) == false);
+    CHECK(psg.isChannelMuted(2) == false);
+
+    psg.setChannelMute(1, true);
+    CHECK(psg.isChannelMuted(1) == true);
+
+    psg.setChannelMute(0, false);
+    CHECK(psg.isChannelMuted(0) == false);
+}
+
+// ============================================================================
+// generateSamples
+// ============================================================================
+
+TEST_CASE("generateSamples produces output", "[ay8910][generate]") {
+    AY8910 psg;
+
+    // Enable tone on channel A, set frequency and volume
+    writeReg(psg, 0, 0x10); // Tone A fine = low period for audible freq
+    writeReg(psg, 1, 0x00); // Tone A coarse
+    writeReg(psg, 7, 0x3E); // Enable tone A only (disable noise all, tone B+C)
+    writeReg(psg, 8, 0x0F); // Channel A volume max
+
+    const int count = 256;
+    std::vector<float> buffer(count, 0.0f);
+    psg.generateSamples(buffer.data(), count, 48000);
+
+    // With a short tone period and max volume, there should be non-zero output
+    float maxAbs = 0.0f;
+    for (int i = 0; i < count; i++) {
+        float absVal = std::fabs(buffer[i]);
+        if (absVal > maxAbs) maxAbs = absVal;
+    }
+    CHECK(maxAbs > 0.0f);
+}
+
+TEST_CASE("generateSamples all channels muted produces silence", "[ay8910][generate]") {
+    AY8910 psg;
+
+    // Set up tone but mute all channels
+    writeReg(psg, 0, 0x10);
+    writeReg(psg, 7, 0x3E);
+    writeReg(psg, 8, 0x0F);
+
+    psg.setChannelMute(0, true);
+    psg.setChannelMute(1, true);
+    psg.setChannelMute(2, true);
+
+    const int count = 128;
+    std::vector<float> buffer(count, 1.0f);
+    psg.generateSamples(buffer.data(), count, 48000);
+
+    for (int i = 0; i < count; i++) {
+        CHECK(buffer[i] == Approx(0.0f));
+    }
+}
+
+// ============================================================================
+// Debug counters
+// ============================================================================
+
+TEST_CASE("Write count tracks register writes", "[ay8910][debug]") {
+    AY8910 psg;
+    CHECK(psg.getWriteCount() == 0);
+
+    writeReg(psg, 0, 0x42);
+    CHECK(psg.getWriteCount() == 1);
+
+    writeReg(psg, 1, 0x03);
+    CHECK(psg.getWriteCount() == 2);
+}
+
+TEST_CASE("Last write tracking", "[ay8910][debug]") {
+    AY8910 psg;
+
+    writeReg(psg, 5, 0xAB);
+    CHECK(psg.getLastWriteReg() == 5);
+    CHECK(psg.getLastWriteVal() == 0xAB);
+}
+
+// ============================================================================
+// State serialization size
+// ============================================================================
+
+TEST_CASE("State serialization exports and imports", "[ay8910][state]") {
+    AY8910 psg1;
+    writeReg(psg1, 0, 0x55);
+    writeReg(psg1, 7, 0x38);
+    writeReg(psg1, 8, 0x0F);
+
+    uint8_t stateBuffer[AY8910::STATE_SIZE];
+    size_t written = psg1.exportState(stateBuffer);
+    REQUIRE(written == AY8910::STATE_SIZE);
+
+    AY8910 psg2;
+    psg2.importState(stateBuffer);
+
+    CHECK(psg2.getRegister(0) == 0x55);
+    CHECK(psg2.getRegister(7) == 0x38);
+    CHECK(psg2.getRegister(8) == 0x0F);
+}