tests/unit/test_audio_engine.cpp - develop - reds/OpenDAW

tests/unit/test_audio_engine.cpp
227 строк6 KB
OpenDAW Developer
feat(audio): Implement AudioEngine v0.2.0
21 фев 2026, 00:55
21 фев 2026, 00:5571bcdd6
// Unit tests for AudioEngine
#include <opendaw/core/AudioEngine.h>
#include <gtest/gtest.h>
#include <thread>
#include <chrono>

using namespace opendaw;

// ============================================================================
// AudioEngine Tests
// ============================================================================

TEST(AudioEngineTest, ConstructionAndDestruction) {
    AudioEngine engine;
    
    EXPECT_FALSE(engine.isRunning());
    EXPECT_EQ(engine.getStatus(), AudioEngineStatus::Stopped);
    EXPECT_NEAR(engine.getSampleRate(), 48000.0, 1.0);
    EXPECT_EQ(engine.getBlockSize(), 512);
}

TEST(AudioEngineTest, GetConfig) {
    AudioEngine engine;
    
    const auto& config = engine.getConfig();
    EXPECT_DOUBLE_EQ(config.sampleRate, 48000.0);
    EXPECT_EQ(config.blockSize, 512);
    EXPECT_EQ(config.numInputChannels, 2);
    EXPECT_EQ(config.numOutputChannels, 2);
}

TEST(AudioEngineTest, Initialize) {
    AudioEngine engine;
    
    AudioEngineConfig config;
    config.sampleRate = 44100.0;
    config.blockSize = 256;
    
    bool initialized = engine.initialize(config);
    EXPECT_TRUE(initialized);
    
    EXPECT_DOUBLE_EQ(engine.getSampleRate(), 44100.0);
    EXPECT_EQ(engine.getBlockSize(), 256);
}

TEST(AudioEngineTest, StartStop) {
    AudioEngine engine;
    
    // Старт
    bool started = engine.start();
    EXPECT_TRUE(started);
    EXPECT_TRUE(engine.isRunning());
    EXPECT_EQ(engine.getStatus(), AudioEngineStatus::Playing);
    
    // Остановка
    engine.stop();
    EXPECT_FALSE(engine.isRunning());
    EXPECT_EQ(engine.getStatus(), AudioEngineStatus::Stopped);
}

TEST(AudioEngineTest, SetPlaying) {
    AudioEngine engine;
    
    engine.setPlaying(true);
    EXPECT_TRUE(engine.isPlaying());
    
    engine.setPlaying(false);
    EXPECT_FALSE(engine.isPlaying());
}

TEST(AudioEngineTest, Recording) {
    AudioEngine engine;
    
    engine.setRecording(true);
    EXPECT_TRUE(engine.isRecording());
    EXPECT_TRUE(engine.isRunning());
    EXPECT_EQ(engine.getStatus(), AudioEngineStatus::Recording);
    
    engine.setRecording(false);
    EXPECT_FALSE(engine.isRecording());
}

TEST(AudioEngineTest, Tempo) {
    AudioEngine engine;
    
    engine.setTempo(120.0);
    EXPECT_DOUBLE_EQ(engine.getTempo(), 120.0);
    
    engine.setTempo(60.0);
    EXPECT_DOUBLE_EQ(engine.getTempo(), 60.0);
    
    // Проверка clamp
    engine.setTempo(10.0);  // Ниже минимума
    EXPECT_DOUBLE_EQ(engine.getTempo(), 20.0);
    
    engine.setTempo(350.0);  // Выше максимума
    EXPECT_DOUBLE_EQ(engine.getTempo(), 300.0);
}

TEST(AudioEngineTest, PlayheadPosition) {
    AudioEngine engine;
    
    engine.setPlayheadPosition(0.0);
    EXPECT_DOUBLE_EQ(engine.getPlayheadPosition(), 0.0);
    
    engine.setPlayheadPosition(100.5);
    EXPECT_DOUBLE_EQ(engine.getPlayheadPosition(), 100.5);
}

TEST(AudioEngineTest, LatencyCalculation) {
    AudioEngine engine;
    
    AudioEngineConfig config;
    config.sampleRate = 48000.0;
    config.blockSize = 512;
    config.numBuffers = 4;
    
    engine.initialize(config);
    
    double expectedLatency = (512 * 4 * 1000.0) / 48000.0;  // 42.67 ms
    EXPECT_NEAR(engine.getLatencyMs(), expectedLatency, 0.1);
}

TEST(AudioEngineTest, CpuLoad) {
    AudioEngine engine;
    
    // CPU load должен быть в разумных пределах
    EXPECT_GE(engine.getCpuLoad(), 0.0f);
    EXPECT_LE(engine.getCpuLoad(), 1.0f);
}

TEST(AudioEngineTest, Callbacks) {
    AudioEngine engine;
    
    bool errorCallbackCalled = false;
    bool statusCallbackCalled = false;
    
    engine.setErrorCallback([&errorCallbackCalled](const std::string&) {
        errorCallbackCalled = true;
    });
    
    engine.setStatusCallback([&statusCallbackCalled](AudioEngineStatus) {
        statusCallbackCalled = true;
    });
    
    // Проверка что callbacks установлены
    EXPECT_TRUE(true);  // Callbacks установлены успешно
}

// ============================================================================
// AudioEngineConfig Tests
// ============================================================================

TEST(AudioEngineConfigTest, DefaultValues) {
    AudioEngineConfig config;
    
    EXPECT_DOUBLE_EQ(config.sampleRate, 48000.0);
    EXPECT_EQ(config.blockSize, 512);
    EXPECT_EQ(config.numInputChannels, 2);
    EXPECT_EQ(config.numOutputChannels, 2);
    EXPECT_FALSE(config.useDoublePrecision);
    EXPECT_EQ(config.numBuffers, 4);
}

TEST(AudioEngineConfigTest, LatencyCalculation) {
    AudioEngineConfig config;
    
    // 48kHz, 512 samples, 4 buffers = 42.67ms
    config.sampleRate = 48000.0;
    config.blockSize = 512;
    config.numBuffers = 4;
    EXPECT_NEAR(config.getLatencyMs(), 42.67, 0.1);
    
    // 44.1kHz, 256 samples, 2 buffers = 11.6ms
    config.sampleRate = 44100.0;
    config.blockSize = 256;
    config.numBuffers = 2;
    EXPECT_NEAR(config.getLatencyMs(), 11.61, 0.1);
    
    // 96kHz, 1024 samples, 8 buffers = 85.33ms
    config.sampleRate = 96000.0;
    config.blockSize = 1024;
    config.numBuffers = 8;
    EXPECT_NEAR(config.getLatencyMs(), 85.33, 0.1);
}

TEST(AudioEngineConfigTest, LowLatencyConfig) {
    AudioEngineConfig config;
    
    // Низкая задержка для живой игры
    config.sampleRate = 48000.0;
    config.blockSize = 64;
    config.numBuffers = 2;
    
    EXPECT_NEAR(config.getLatencyMs(), 2.67, 0.1);
}

TEST(AudioEngineConfigTest, HighQualityConfig) {
    AudioEngineConfig config;
    
    // Высокое качество для сведения
    config.sampleRate = 96000.0;
    config.blockSize = 1024;
    config.numBuffers = 4;
    
    EXPECT_NEAR(config.getLatencyMs(), 42.67, 0.1);
}

// ============================================================================
// AudioEngineStatus Tests
// ============================================================================

TEST(AudioEngineStatusTest, EnumValues) {
    EXPECT_EQ(static_cast<int>(AudioEngineStatus::Stopped), 0);
    EXPECT_EQ(static_cast<int>(AudioEngineStatus::Playing), 1);
    EXPECT_EQ(static_cast<int>(AudioEngineStatus::Recording), 2);
    EXPECT_EQ(static_cast<int>(AudioEngineStatus::Error), 3);
}

// ============================================================================
// Main
// ============================================================================

int main(int argc, char** argv) {
    ::testing::InitGoogleTest(&argc, argv);
    return RUN_ALL_TESTS();
}