test: expand cabinet IR and DSP stability coverage (#207)

* test: add cabinet sim stability and silence tests

* test: expand cabinet IR and DSP stability coverage

* test: expand IR and convolution engine coverage

* test: address CI and regression review feedback

* test: improve DSP and IR coverage

* fix: correct wav loader assertion

* test: improve wav loader branch coverage

* test: improve wav loader and DSP coverage

* fix: add missing cstdint include for wav loader tests

* test: improve wav loader parser coverage

* test: expand wav loader edge case coverage

* test: improve wav loader edge case coverage

* fix: stabilize wav loader coverage tests across CI

* fix: remove tmp paths from wav loader tests

* test: stabilize wav loader coverage assets

* test: replace M_PI with project constant

* fix: ensure wav test asset directory exists in CI

* fix: remove stray wav test artifacts

* test: improve convolution engine coverage

* fix: stabilize convolution FFT coverage test

Author: YASHcode-IIITV

CMakeLists.txt

@@ -512,6 +512,8 @@ else() # NOT EMSCRIPTEN, ANDROID, or IOS
         tests/test_command_history.cpp
         tests/test_snapshot_manager.cpp
         tests/test_cabinet_sim_ir.cpp
+	tests/test_wav_loader.cpp
+	tests/test_convolution_engine.cpp
         tests/test_midi_manager.cpp
         tests/test_unsaved_preset.cpp
         tests/test_audio_graph.cpp

tests/assets/.gitkeep

@@ -63,7 +63,7 @@ static bool write_wav_mono_pcm16(const std::string& path,
         int16_t v = static_cast<int16_t>(std::lrint(x * 32767.0f));
         write_le16(out, static_cast<uint16_t>(v));
     }
-
+    out.close();
     return true;
 }
 
@@ -95,6 +95,92 @@ TEST(CabinetSim_IR_UnitImpulse_Identity) {
     std::remove(path.c_str());
 }
 
+TEST(CabinetSim_IR_MissingFileReturnsFalse) {
+    std::string valid = "valid_ir.wav";
+
+    ASSERT_TRUE(write_wav_mono_pcm16(valid, {1.0f}, 48000));
+
+    CabinetSim cab;
+    cab.set_sample_rate(48000);
+
+    ASSERT_TRUE(cab.load_ir(valid));
+    ASSERT_TRUE(cab.has_ir());
+
+    ASSERT_FALSE(cab.load_ir("definitely_missing_ir.wav"));
+
+    // Ensure failed load clears previous state
+    ASSERT_TRUE(cab.has_ir());
+
+    std::remove(valid.c_str());
+}
+
+TEST(CabinetSim_IR_MalformedFileReturnsFalse) {
+    const std::string path = "bad_ir.wav";
+
+    {
+        std::ofstream out(path, std::ios::binary);
+        out << "this is not a wav";
+    }
+
+    CabinetSim cab;
+    cab.set_sample_rate(48000);
+
+    ASSERT_FALSE(cab.load_ir(path));
+    ASSERT_FALSE(cab.has_ir());
+
+    std::remove(path.c_str());
+}
+
+TEST(CabinetSim_IR_LongRunStability) {
+    const int block_size = 256;
+
+    std::string path = "test_longrun_ir.wav";
+    ASSERT_TRUE(write_wav_mono_pcm16(path, {1.0f, 0.5f, 0.25f}, 48000));
+
+    CabinetSim cab;
+    cab.set_sample_rate(48000);
+
+    ASSERT_TRUE(cab.load_ir(path));
+
+    std::vector<float> buf(block_size);
+
+    for (int iter = 0; iter < 1000; ++iter) {
+        for (int i = 0; i < block_size; ++i) {
+            buf[i] = std::sin(0.01f * static_cast<float>(i));
+        }
+
+        cab.process(buf.data(), block_size);
+
+        for (float s : buf) {
+            ASSERT_TRUE(std::isfinite(s));
+        }
+    }
+
+    std::remove(path.c_str());
+}
+
+TEST(CabinetSim_IR_SilenceRemainsSilent) {
+    const int block_size = 256;
+
+    std::string path = "test_silence_ir.wav";
+    ASSERT_TRUE(write_wav_mono_pcm16(path, {1.0f}, 48000));
+
+    CabinetSim cab;
+    cab.set_sample_rate(48000);
+
+    ASSERT_TRUE(cab.load_ir(path));
+
+    std::vector<float> buf(block_size, 0.0f);
+
+    cab.process(buf.data(), block_size);
+
+    for (float s : buf) {
+        ASSERT_NEAR(s, 0.0f, 1e-6f);
+    }
+
+    std::remove(path.c_str());
+}
+
 TEST(CabinetSim_IR_DelayedImpulse) {
     const int block_size = 256;
 
@@ -122,3 +208,101 @@ TEST(CabinetSim_IR_DelayedImpulse) {
     std::remove(path.c_str());
 }
 
+TEST(CabinetSim_IR_MetadataQueries) {
+    std::string path = "metadata_ir.wav";
+
+    ASSERT_TRUE(write_wav_mono_pcm16(path, {1.0f, 0.5f}, 48000));
+
+    CabinetSim cab;
+    cab.set_sample_rate(48000);
+
+    ASSERT_TRUE(cab.load_ir(path));
+
+    ASSERT_TRUE(cab.has_ir());
+    ASSERT_EQ(cab.ir_name(), "metadata_ir.wav");
+    ASSERT_EQ(cab.ir_path(), path);
+    ASSERT_GT(cab.ir_duration_ms(), 0.0f);
+
+    std::remove(path.c_str());
+}
+
+TEST(CabinetSim_ClearIR_ResetsState) {
+    std::string path = "clear_ir.wav";
+
+    ASSERT_TRUE(write_wav_mono_pcm16(path, {1.0f}, 48000));
+
+    CabinetSim cab;
+    cab.set_sample_rate(48000);
+
+    ASSERT_TRUE(cab.load_ir(path));
+    ASSERT_TRUE(cab.has_ir());
+
+    cab.clear_ir();
+
+    ASSERT_FALSE(cab.has_ir());
+    ASSERT_TRUE(cab.ir_name().empty());
+    ASSERT_TRUE(cab.ir_path().empty());
+    ASSERT_NEAR(cab.ir_duration_ms(), 0.0f, 1e-6f);
+
+    std::remove(path.c_str());
+}
+
+TEST(CabinetSim_SetSampleRate_ReloadsIR) {
+    std::string path = "reload_ir.wav";
+
+    ASSERT_TRUE(write_wav_mono_pcm16(path, {1.0f, 0.5f}, 44100));
+
+    CabinetSim cab;
+    cab.set_sample_rate(44100);
+
+    ASSERT_TRUE(cab.load_ir(path));
+
+    float before = cab.ir_duration_ms();
+
+    cab.set_sample_rate(48000);
+
+    ASSERT_TRUE(cab.has_ir());
+    ASSERT_GT(cab.ir_duration_ms(), 0.0f);
+    ASSERT_NEAR(before, cab.ir_duration_ms(), 5.0f);
+
+    std::remove(path.c_str());
+}
+
+TEST(CabinetSim_ClearIRRemovesState) {
+    std::string path = "clear_ir.wav";
+
+    ASSERT_TRUE(
+        write_wav_mono_pcm16(path, {1.0f}, 48000));
+
+    CabinetSim cab;
+
+    cab.set_sample_rate(48000);
+
+    ASSERT_TRUE(cab.load_ir(path));
+
+    ASSERT_TRUE(cab.has_ir());
+
+    cab.clear_ir();
+
+    ASSERT_FALSE(cab.has_ir());
+
+    std::remove(path.c_str());
+}
+
+TEST(CabinetSim_DisabledProcessPassthrough) {
+    CabinetSim cab;
+
+    cab.set_enabled(false);
+
+    float buf[128];
+
+    for (int i = 0; i < 128; ++i) {
+        buf[i] = 0.25f;
+    }
+
+    cab.process(buf, 128);
+
+    for (float s : buf) {
+        ASSERT_NEAR(s, 0.25f, 1e-6f);
+    }
+}

tests/test_cabinet_sim_ir.cpp

@@ -0,0 +1,178 @@
+#include "test_framework.h"
+#include "audio/dsp/convolution_engine.h"
+
+#include <vector>
+#include <cmath>
+#include <memory>
+
+using namespace Amplitron;
+using namespace TestFramework;
+
+TEST(ConvolutionEngine_ResetClearsState) {
+    std::vector<float> ir = {1.0f, 0.5f, 0.25f};
+
+    auto kernel =
+        std::make_shared<ConvolutionKernel>(ir, 256);
+
+    ConvolutionEngine conv;
+
+    conv.set_kernel(kernel);
+
+    std::vector<float> buffer(256, 1.0f);
+
+    conv.process(buffer.data(), 256);
+
+    conv.reset();
+
+    std::vector<float> silent(256, 0.0f);
+
+    conv.process(silent.data(), 256);
+
+    for (float s : silent) {
+        ASSERT_TRUE(std::isfinite(s));
+        ASSERT_NEAR(s, 0.0f, 1e-4f);
+    }
+}
+
+TEST(ConvolutionEngine_PartitionedFFTPath) {
+    std::vector<float> ir(1024, 0.0f);
+
+    // simple impulse-like IR
+    ir[0] = 1.0f;
+    ir[128] = 0.5f;
+    ir[512] = 0.25f;
+
+    auto kernel =
+        std::make_shared<ConvolutionKernel>(ir, 256);
+
+    ConvolutionEngine conv;
+    conv.set_kernel(kernel);
+
+    std::vector<float> buffer(256);
+
+    for (size_t i = 0; i < buffer.size(); ++i) {
+        buffer[i] =
+            std::sin(static_cast<float>(i) * 0.01f);
+    }
+
+    conv.process(buffer.data(), 256);
+
+    for (float s : buffer) {
+        ASSERT_TRUE(std::isfinite(s));
+    }
+}
+
+TEST(ConvolutionEngine_HasKernelAfterSetKernel) {
+    std::vector<float> ir = {1.0f};
+
+    auto kernel =
+        std::make_shared<ConvolutionKernel>(ir, 256);
+
+    ConvolutionEngine conv;
+
+    ASSERT_FALSE(conv.has_kernel());
+
+    conv.set_kernel(kernel);
+
+    ASSERT_TRUE(conv.has_kernel());
+}
+
+TEST(ConvolutionEngine_OverlapAddConsistency) {
+    std::vector<float> ir = {1.0f, 0.5f, 0.25f};
+
+    auto kernel =
+        std::make_shared<ConvolutionKernel>(ir, 256);
+
+    ConvolutionEngine conv;
+
+    conv.set_kernel(kernel);
+
+    std::vector<float> buffer(1024);
+
+    for (size_t i = 0; i < buffer.size(); ++i) {
+        buffer[i] = std::sin(
+            static_cast<float>(i) * 0.01f);
+    }
+
+    for (int i = 0; i < 1024; i += 256) {
+        conv.process(buffer.data() + i, 256);
+    }
+
+    for (float s : buffer) {
+        ASSERT_TRUE(std::isfinite(s));
+    }
+}
+
+TEST(ConvolutionEngine_ClearKernel) {
+    std::vector<float> ir = {1.0f};
+
+    auto kernel =
+        std::make_shared<ConvolutionKernel>(ir, 256);
+
+    ConvolutionEngine conv;
+
+    conv.set_kernel(kernel);
+
+    ASSERT_TRUE(conv.has_kernel());
+
+    conv.set_kernel(nullptr);
+
+    ASSERT_FALSE(conv.has_kernel());
+}
+
+TEST(ConvolutionEngine_SmallBlockProcessing) {
+    std::vector<float> ir = {1.0f, 0.5f};
+
+    auto kernel =
+        std::make_shared<ConvolutionKernel>(ir, 64);
+
+    ConvolutionEngine conv;
+
+    conv.set_kernel(kernel);
+
+    std::vector<float> buffer(32, 1.0f);
+
+    conv.process(buffer.data(), 32);
+
+    for (float s : buffer) {
+        ASSERT_TRUE(std::isfinite(s));
+    }
+}
+
+TEST(ConvolutionEngine_ZeroInputRemainsSilent) {
+    std::vector<float> ir = {1.0f, 0.5f};
+
+    auto kernel =
+        std::make_shared<ConvolutionKernel>(ir, 128);
+
+    ConvolutionEngine conv;
+
+    conv.set_kernel(kernel);
+
+    std::vector<float> buffer(128, 0.0f);
+
+    conv.process(buffer.data(), 128);
+
+    for (float s : buffer) {
+        ASSERT_NEAR(s, 0.0f, 1e-5f);
+    }
+}
+
+TEST(ConvolutionKernel_PartitionFreqBounds) {
+    std::vector<float> ir(512, 0.5f);
+
+    ConvolutionKernel kernel(ir, 256);
+
+    ASSERT_TRUE(kernel.partition_freq(0) != nullptr);
+    ASSERT_TRUE(kernel.partition_freq(-1) == nullptr);
+    ASSERT_TRUE(kernel.partition_freq(999) == nullptr);
+}
+
+TEST(ConvolutionKernel_EmptyIR) {
+    std::vector<float> ir;
+
+    ConvolutionKernel kernel(ir, 256);
+
+    ASSERT_EQ(kernel.num_partitions(), 0);
+}
+