489 lines
16 KiB
C++
489 lines
16 KiB
C++
// ================================================================================================
|
||
// Audio Backend - 插件加载测试
|
||
// ================================================================================================
|
||
|
||
#include <gtest/gtest.h>
|
||
#include <gmock/gmock.h>
|
||
#include "plugin_host/core/plugin_interface.h"
|
||
#include "plugin_host/core/plugin_metadata.h"
|
||
#include "plugin_host/manager/plugin_host_manager.h"
|
||
#include "tests/common/test_fixtures.h"
|
||
#include <filesystem>
|
||
#include <thread>
|
||
#include <chrono>
|
||
|
||
using namespace audio_backend;
|
||
using namespace audio_backend::plugin_host;
|
||
using namespace std::chrono_literals;
|
||
|
||
// 创建测试插件实现
|
||
class TestPlugin : public IPlugin {
|
||
public:
|
||
TestPlugin(PluginInfo info) : info_(std::move(info)) {}
|
||
virtual ~TestPlugin() = default;
|
||
|
||
// 实现插件接口
|
||
bool initialize(const PluginInitParams& params) override {
|
||
initialized_ = true;
|
||
params_ = params;
|
||
return true;
|
||
}
|
||
|
||
bool terminate() override {
|
||
initialized_ = false;
|
||
return true;
|
||
}
|
||
|
||
bool activate() override {
|
||
active_ = true;
|
||
return true;
|
||
}
|
||
|
||
bool deactivate() override {
|
||
active_ = false;
|
||
return true;
|
||
}
|
||
|
||
PluginProcessStatus process(const ProcessContext& context) override {
|
||
last_context_ = context;
|
||
return PluginProcessStatus::Success;
|
||
}
|
||
|
||
PluginInfo get_info() const override {
|
||
return info_;
|
||
}
|
||
|
||
ParameterInfo get_parameter_info(ParameterId param_id) const override {
|
||
auto it = parameters_.find(param_id);
|
||
if (it != parameters_.end()) {
|
||
return it->second.info;
|
||
}
|
||
return ParameterInfo();
|
||
}
|
||
|
||
float get_parameter(ParameterId param_id) const override {
|
||
auto it = parameters_.find(param_id);
|
||
if (it != parameters_.end()) {
|
||
return it->second.value;
|
||
}
|
||
return 0.0f;
|
||
}
|
||
|
||
bool set_parameter(ParameterId param_id, float value) override {
|
||
auto it = parameters_.find(param_id);
|
||
if (it != parameters_.end()) {
|
||
it->second.value = value;
|
||
return true;
|
||
}
|
||
return false;
|
||
}
|
||
|
||
bool handle_event(const PluginEvent& event) override {
|
||
last_event_ = event;
|
||
return true;
|
||
}
|
||
|
||
const PluginStatistics& get_statistics() const override {
|
||
return stats_;
|
||
}
|
||
|
||
void reset_statistics() override {
|
||
stats_ = PluginStatistics();
|
||
}
|
||
|
||
// 测试辅助方法
|
||
void add_parameter(ParameterId id, const ParameterInfo& info, float default_value) {
|
||
parameters_[id] = {info, default_value};
|
||
}
|
||
|
||
bool is_initialized() const { return initialized_; }
|
||
bool is_active() const { return active_; }
|
||
const PluginInitParams& get_params() const { return params_; }
|
||
const ProcessContext& get_last_context() const { return last_context_; }
|
||
const PluginEvent& get_last_event() const { return last_event_; }
|
||
|
||
private:
|
||
PluginInfo info_;
|
||
bool initialized_ = false;
|
||
bool active_ = false;
|
||
PluginInitParams params_;
|
||
ProcessContext last_context_;
|
||
PluginEvent last_event_;
|
||
PluginStatistics stats_;
|
||
|
||
struct Parameter {
|
||
ParameterInfo info;
|
||
float value;
|
||
};
|
||
|
||
std::map<ParameterId, Parameter> parameters_;
|
||
};
|
||
|
||
// 创建模拟插件工厂
|
||
class MockPluginFactory {
|
||
public:
|
||
static std::unique_ptr<IPlugin> create_test_plugin(
|
||
const std::string& id,
|
||
const std::string& name,
|
||
const std::string& version) {
|
||
|
||
PluginInfo info;
|
||
info.id = id;
|
||
info.name = name;
|
||
info.version = version;
|
||
info.vendor = "Test Vendor";
|
||
info.category = "Test";
|
||
info.description = "Test plugin for unit tests";
|
||
info.num_inputs = 2;
|
||
info.num_outputs = 2;
|
||
|
||
return std::make_unique<TestPlugin>(info);
|
||
}
|
||
};
|
||
|
||
// 创建模拟插件加载器
|
||
class MockPluginLoader : public IPluginLoader {
|
||
public:
|
||
MockPluginLoader() = default;
|
||
~MockPluginLoader() override = default;
|
||
|
||
// 实现加载器接口
|
||
PluginLoadResult load_plugin(
|
||
const std::string& plugin_path,
|
||
PluginInstanceId instance_id,
|
||
const PluginLoadConfig& config) override {
|
||
|
||
// 检查路径是否在已加载插件表中
|
||
auto it = plugins_.find(plugin_path);
|
||
if (it != plugins_.end()) {
|
||
return {PluginLoadStatus::AlreadyLoaded, nullptr,
|
||
"Plugin already loaded with instance ID " + std::to_string(it->second.instance_id)};
|
||
}
|
||
|
||
// 创建测试插件
|
||
auto plugin = MockPluginFactory::create_test_plugin(
|
||
plugin_path, // 使用路径作为ID
|
||
std::filesystem::path(plugin_path).filename().string(), // 使用文件名作为名称
|
||
"1.0.0" // 默认版本
|
||
);
|
||
|
||
if (!plugin) {
|
||
return {PluginLoadStatus::LoadError, nullptr, "Failed to create plugin"};
|
||
}
|
||
|
||
// 初始化插件
|
||
PluginInitParams params;
|
||
params.sample_rate = config.sample_rate;
|
||
params.max_block_size = config.block_size;
|
||
params.plugin_path = plugin_path;
|
||
params.host_api_version = HOST_API_VERSION;
|
||
|
||
if (!plugin->initialize(params)) {
|
||
return {PluginLoadStatus::InitError, nullptr, "Failed to initialize plugin"};
|
||
}
|
||
|
||
// 存储插件信息
|
||
plugins_[plugin_path] = {instance_id, plugin.get()};
|
||
|
||
// 返回成功结果
|
||
return {PluginLoadStatus::Success, std::move(plugin), ""};
|
||
}
|
||
|
||
bool unload_plugin(PluginInstanceId instance_id) override {
|
||
// 查找插件
|
||
for (auto it = plugins_.begin(); it != plugins_.end(); ++it) {
|
||
if (it->second.instance_id == instance_id) {
|
||
plugins_.erase(it);
|
||
return true;
|
||
}
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
// 测试辅助方法
|
||
size_t get_loaded_plugin_count() const {
|
||
return plugins_.size();
|
||
}
|
||
|
||
private:
|
||
struct PluginEntry {
|
||
PluginInstanceId instance_id;
|
||
IPlugin* plugin_ptr; // 仅用于测试，不拥有对象
|
||
};
|
||
|
||
std::map<std::string, PluginEntry> plugins_;
|
||
};
|
||
|
||
// 插件加载测试固定装置
|
||
class PluginLoadTest : public test::PluginSandboxTest {
|
||
protected:
|
||
void SetUp() override {
|
||
test::PluginSandboxTest::SetUp();
|
||
|
||
// 创建插件加载器
|
||
loader_ = std::make_shared<MockPluginLoader>();
|
||
|
||
// 创建插件宿主管理器
|
||
manager_ = std::make_unique<PluginHostManager>();
|
||
|
||
// 初始化管理器
|
||
PluginHostConfig config;
|
||
config.default_sample_rate = 48000;
|
||
config.default_block_size = 512;
|
||
config.enable_sandbox = false; // 禁用沙盒进行单元测试
|
||
config.plugin_search_paths = {"./plugins", "./effects"};
|
||
config.cache_loaded_plugins = true;
|
||
|
||
ASSERT_EQ(manager_->initialize(config), common::ErrorCode::Success);
|
||
|
||
// 注册加载器
|
||
manager_->register_plugin_loader(loader_);
|
||
}
|
||
|
||
void TearDown() override {
|
||
if (manager_->is_initialized()) {
|
||
manager_->shutdown();
|
||
}
|
||
|
||
manager_.reset();
|
||
loader_.reset();
|
||
|
||
test::PluginSandboxTest::TearDown();
|
||
}
|
||
|
||
// 创建测试插件加载配置
|
||
PluginLoadConfig create_load_config() {
|
||
PluginLoadConfig config;
|
||
config.sample_rate = 48000;
|
||
config.block_size = 512;
|
||
config.enable_sandbox = false;
|
||
return config;
|
||
}
|
||
|
||
protected:
|
||
std::shared_ptr<MockPluginLoader> loader_;
|
||
std::unique_ptr<PluginHostManager> manager_;
|
||
};
|
||
|
||
// 测试插件加载
|
||
TEST_F(PluginLoadTest, LoadPlugin) {
|
||
// 创建加载配置
|
||
PluginLoadConfig config = create_load_config();
|
||
|
||
// 加载插件
|
||
PluginInstanceId instance_id = 0;
|
||
ASSERT_EQ(manager_->load_plugin("./plugins/test_plugin.dll", instance_id, config), common::ErrorCode::Success);
|
||
|
||
// 验证插件ID
|
||
EXPECT_NE(instance_id, 0);
|
||
|
||
// 验证插件已加载
|
||
EXPECT_TRUE(manager_->is_plugin_loaded(instance_id));
|
||
EXPECT_EQ(loader_->get_loaded_plugin_count(), 1);
|
||
|
||
// 获取插件信息
|
||
PluginInstanceInfo info;
|
||
ASSERT_EQ(manager_->get_plugin_info(instance_id, info), common::ErrorCode::Success);
|
||
|
||
// 验证插件信息
|
||
EXPECT_EQ(info.plugin_id, "./plugins/test_plugin.dll");
|
||
EXPECT_EQ(info.instance_id, instance_id);
|
||
EXPECT_EQ(info.state, PluginState::Initialized);
|
||
}
|
||
|
||
// 测试插件激活和停用
|
||
TEST_F(PluginLoadTest, ActivateDeactivatePlugin) {
|
||
// 加载插件
|
||
PluginInstanceId instance_id = 0;
|
||
PluginLoadConfig config = create_load_config();
|
||
ASSERT_EQ(manager_->load_plugin("./plugins/test_plugin.dll", instance_id, config), common::ErrorCode::Success);
|
||
|
||
// 验证初始状态
|
||
PluginInstanceInfo info;
|
||
ASSERT_EQ(manager_->get_plugin_info(instance_id, info), common::ErrorCode::Success);
|
||
EXPECT_EQ(info.state, PluginState::Initialized);
|
||
|
||
// 激活插件
|
||
ASSERT_EQ(manager_->activate_plugin(instance_id), common::ErrorCode::Success);
|
||
|
||
// 验证激活状态
|
||
ASSERT_EQ(manager_->get_plugin_info(instance_id, info), common::ErrorCode::Success);
|
||
EXPECT_EQ(info.state, PluginState::Active);
|
||
|
||
// 停用插件
|
||
ASSERT_EQ(manager_->deactivate_plugin(instance_id), common::ErrorCode::Success);
|
||
|
||
// 验证停用状态
|
||
ASSERT_EQ(manager_->get_plugin_info(instance_id, info), common::ErrorCode::Success);
|
||
EXPECT_EQ(info.state, PluginState::Initialized);
|
||
}
|
||
|
||
// 测试插件卸载
|
||
TEST_F(PluginLoadTest, UnloadPlugin) {
|
||
// 加载插件
|
||
PluginInstanceId instance_id = 0;
|
||
PluginLoadConfig config = create_load_config();
|
||
ASSERT_EQ(manager_->load_plugin("./plugins/test_plugin.dll", instance_id, config), common::ErrorCode::Success);
|
||
|
||
// 验证插件已加载
|
||
EXPECT_TRUE(manager_->is_plugin_loaded(instance_id));
|
||
|
||
// 卸载插件
|
||
ASSERT_EQ(manager_->unload_plugin(instance_id), common::ErrorCode::Success);
|
||
|
||
// 验证插件已卸载
|
||
EXPECT_FALSE(manager_->is_plugin_loaded(instance_id));
|
||
EXPECT_EQ(loader_->get_loaded_plugin_count(), 0);
|
||
}
|
||
|
||
// 测试加载多个插件
|
||
TEST_F(PluginLoadTest, LoadMultiplePlugins) {
|
||
// 加载第一个插件
|
||
PluginInstanceId id1 = 0;
|
||
PluginLoadConfig config = create_load_config();
|
||
ASSERT_EQ(manager_->load_plugin("./plugins/plugin1.dll", id1, config), common::ErrorCode::Success);
|
||
|
||
// 加载第二个插件
|
||
PluginInstanceId id2 = 0;
|
||
ASSERT_EQ(manager_->load_plugin("./plugins/plugin2.dll", id2, config), common::ErrorCode::Success);
|
||
|
||
// 加载第三个插件
|
||
PluginInstanceId id3 = 0;
|
||
ASSERT_EQ(manager_->load_plugin("./plugins/plugin3.dll", id3, config), common::ErrorCode::Success);
|
||
|
||
// 验证插件已加载
|
||
EXPECT_TRUE(manager_->is_plugin_loaded(id1));
|
||
EXPECT_TRUE(manager_->is_plugin_loaded(id2));
|
||
EXPECT_TRUE(manager_->is_plugin_loaded(id3));
|
||
EXPECT_EQ(loader_->get_loaded_plugin_count(), 3);
|
||
|
||
// 验证ID不同
|
||
EXPECT_NE(id1, id2);
|
||
EXPECT_NE(id1, id3);
|
||
EXPECT_NE(id2, id3);
|
||
|
||
// 获取所有插件ID
|
||
std::vector<PluginInstanceId> ids;
|
||
ASSERT_EQ(manager_->get_all_plugin_instances(ids), common::ErrorCode::Success);
|
||
|
||
// 验证ID列表
|
||
EXPECT_EQ(ids.size(), 3);
|
||
EXPECT_TRUE(std::find(ids.begin(), ids.end(), id1) != ids.end());
|
||
EXPECT_TRUE(std::find(ids.begin(), ids.end(), id2) != ids.end());
|
||
EXPECT_TRUE(std::find(ids.begin(), ids.end(), id3) != ids.end());
|
||
}
|
||
|
||
// 测试重复加载
|
||
TEST_F(PluginLoadTest, LoadDuplicatePlugin) {
|
||
// 加载插件
|
||
PluginInstanceId id1 = 0;
|
||
PluginLoadConfig config = create_load_config();
|
||
ASSERT_EQ(manager_->load_plugin("./plugins/test_plugin.dll", id1, config), common::ErrorCode::Success);
|
||
|
||
// 尝试再次加载同一个插件
|
||
PluginInstanceId id2 = 0;
|
||
auto result = manager_->load_plugin("./plugins/test_plugin.dll", id2, config);
|
||
|
||
// 应该返回错误
|
||
EXPECT_NE(result, common::ErrorCode::Success);
|
||
|
||
// 验证只有一个插件加载
|
||
EXPECT_EQ(loader_->get_loaded_plugin_count(), 1);
|
||
}
|
||
|
||
// 测试参数操作
|
||
TEST_F(PluginLoadTest, ParameterOperations) {
|
||
// 加载插件
|
||
PluginInstanceId instance_id = 0;
|
||
PluginLoadConfig config = create_load_config();
|
||
ASSERT_EQ(manager_->load_plugin("./plugins/test_plugin.dll", instance_id, config), common::ErrorCode::Success);
|
||
|
||
// 获取插件实例
|
||
auto plugin = manager_->get_plugin(instance_id);
|
||
ASSERT_NE(plugin, nullptr);
|
||
|
||
// 添加测试参数（使用TestPlugin的特定方法）
|
||
auto* test_plugin = dynamic_cast<TestPlugin*>(plugin.get());
|
||
ASSERT_NE(test_plugin, nullptr);
|
||
|
||
ParameterInfo gain_param;
|
||
gain_param.id = 1;
|
||
gain_param.name = "Gain";
|
||
gain_param.default_value = 0.5f;
|
||
gain_param.min_value = 0.0f;
|
||
gain_param.max_value = 1.0f;
|
||
|
||
test_plugin->add_parameter(1, gain_param, 0.5f);
|
||
|
||
// 获取参数信息
|
||
ParameterInfo info;
|
||
ASSERT_EQ(manager_->get_parameter_info(instance_id, 1, info), common::ErrorCode::Success);
|
||
|
||
// 验证参数信息
|
||
EXPECT_EQ(info.id, 1);
|
||
EXPECT_EQ(info.name, "Gain");
|
||
EXPECT_FLOAT_EQ(info.default_value, 0.5f);
|
||
EXPECT_FLOAT_EQ(info.min_value, 0.0f);
|
||
EXPECT_FLOAT_EQ(info.max_value, 1.0f);
|
||
|
||
// 获取参数值
|
||
float value = 0.0f;
|
||
ASSERT_EQ(manager_->get_parameter_value(instance_id, 1, value), common::ErrorCode::Success);
|
||
EXPECT_FLOAT_EQ(value, 0.5f);
|
||
|
||
// 设置参数值
|
||
ASSERT_EQ(manager_->set_parameter_value(instance_id, 1, 0.8f), common::ErrorCode::Success);
|
||
|
||
// 再次获取参数值
|
||
ASSERT_EQ(manager_->get_parameter_value(instance_id, 1, value), common::ErrorCode::Success);
|
||
EXPECT_FLOAT_EQ(value, 0.8f);
|
||
|
||
// 尝试获取不存在的参数
|
||
EXPECT_NE(manager_->get_parameter_value(instance_id, 999, value), common::ErrorCode::Success);
|
||
}
|
||
|
||
// 测试批量处理操作
|
||
TEST_F(PluginLoadTest, ProcessOperations) {
|
||
// 加载插件
|
||
PluginInstanceId instance_id = 0;
|
||
PluginLoadConfig config = create_load_config();
|
||
ASSERT_EQ(manager_->load_plugin("./plugins/test_plugin.dll", instance_id, config), common::ErrorCode::Success);
|
||
|
||
// 激活插件
|
||
ASSERT_EQ(manager_->activate_plugin(instance_id), common::ErrorCode::Success);
|
||
|
||
// 准备处理上下文
|
||
ProcessContext context;
|
||
context.input_buffer = std::make_shared<AudioBuffer>(512, 2, AudioFormat::FLOAT32);
|
||
context.output_buffer = std::make_shared<AudioBuffer>(512, 2, AudioFormat::FLOAT32);
|
||
context.time_info.sample_position = 0;
|
||
context.time_info.sample_rate = 48000;
|
||
context.time_info.tempo = 120.0;
|
||
|
||
// 填充输入缓冲区
|
||
float* input_data = context.input_buffer->interleaved_data<float>();
|
||
for (size_t i = 0; i < 512 * 2; ++i) {
|
||
input_data[i] = 0.5f;
|
||
}
|
||
|
||
// 处理音频
|
||
ASSERT_EQ(manager_->process_audio(instance_id, context), common::ErrorCode::Success);
|
||
|
||
// 验证输出缓冲区（具体处理结果取决于TestPlugin的实现）
|
||
// 在这个测试中，TestPlugin没有实际处理音频，只是记录上下文
|
||
// 所以我们验证上下文已被正确传递
|
||
|
||
auto plugin = manager_->get_plugin(instance_id);
|
||
auto* test_plugin = dynamic_cast<TestPlugin*>(plugin.get());
|
||
ASSERT_NE(test_plugin, nullptr);
|
||
|
||
const auto& last_context = test_plugin->get_last_context();
|
||
EXPECT_EQ(last_context.time_info.sample_rate, context.time_info.sample_rate);
|
||
EXPECT_EQ(last_context.time_info.tempo, context.time_info.tempo);
|
||
}
|
||
|
||
int main(int argc, char** argv) {
|
||
::testing::InitGoogleTest(&argc, argv);
|
||
return RUN_ALL_TESTS();
|
||
} |