495 lines
17 KiB
C++
495 lines
17 KiB
C++
// ================================================================================================
|
|
// Audio Backend - 设备管理器测试
|
|
// ================================================================================================
|
|
|
|
#include <gtest/gtest.h>
|
|
#include <gmock/gmock.h>
|
|
#include "frontend/device/device_manager.h"
|
|
#include "tests/common/test_fixtures.h"
|
|
#include <thread>
|
|
#include <chrono>
|
|
#include <memory>
|
|
#include <vector>
|
|
#include <string>
|
|
|
|
using namespace audio_backend;
|
|
using namespace audio_backend::frontend;
|
|
using namespace std::chrono_literals;
|
|
|
|
// 创建模拟设备事件监听器
|
|
class MockDeviceEventListener : public IDeviceEventListener {
|
|
public:
|
|
MOCK_METHOD(void, on_device_added, (const AudioDeviceInfo&), (override));
|
|
MOCK_METHOD(void, on_device_removed, (const std::string&), (override));
|
|
MOCK_METHOD(void, on_device_state_changed, (const std::string&, DeviceState, DeviceState), (override));
|
|
MOCK_METHOD(void, on_default_device_changed, (DeviceType, const std::string&), (override));
|
|
MOCK_METHOD(void, on_device_config_changed, (const std::string&, const DeviceConfiguration&), (override));
|
|
MOCK_METHOD(void, on_audio_data_available, (const std::string&, const engine::AudioBuffer&), (override));
|
|
MOCK_METHOD(void, on_device_error, (const std::string&, common::ErrorCode, const std::string&), (override));
|
|
};
|
|
|
|
// 前端设备管理器测试固定装置
|
|
class DeviceManagerTest : public test::FrontendTest {
|
|
protected:
|
|
void SetUp() override {
|
|
test::FrontendTest::SetUp();
|
|
|
|
// 创建设备管理器配置
|
|
DeviceManagerConfig config;
|
|
config.auto_detect_devices = true;
|
|
config.enable_hot_plug_detection = true;
|
|
config.device_scan_interval_ms = 500; // 缩短扫描间隔用于测试
|
|
config.default_buffer_size = 256;
|
|
config.enable_device_monitoring = true;
|
|
|
|
// 创建设备管理器
|
|
device_manager_ = device_factory::create_device_manager(config);
|
|
|
|
// 创建模拟事件监听器
|
|
event_listener_ = std::make_shared<::testing::NiceMock<MockDeviceEventListener>>();
|
|
|
|
// 添加事件监听器
|
|
device_manager_->add_event_listener(event_listener_);
|
|
}
|
|
|
|
void TearDown() override {
|
|
// 移除事件监听器
|
|
if (event_listener_ && device_manager_) {
|
|
device_manager_->remove_event_listener(event_listener_);
|
|
}
|
|
|
|
// 如果已初始化，则关闭设备管理器
|
|
if (device_manager_ && device_manager_->is_initialized()) {
|
|
device_manager_->shutdown();
|
|
}
|
|
|
|
device_manager_.reset();
|
|
event_listener_.reset();
|
|
|
|
test::FrontendTest::TearDown();
|
|
}
|
|
|
|
// 创建测试设备配置
|
|
DeviceConfiguration create_test_config(const std::string& device_id) {
|
|
DeviceConfiguration config;
|
|
config.device_id = device_id;
|
|
config.sample_rate = 48000;
|
|
config.channels = 2;
|
|
config.format = engine::AudioFormat::FLOAT32;
|
|
config.buffer_size = 256;
|
|
config.exclusive_mode = false;
|
|
config.enable_monitoring = true;
|
|
config.volume = 0.8;
|
|
config.muted = false;
|
|
return config;
|
|
}
|
|
|
|
// 等待设备扫描完成
|
|
void wait_for_device_scan() {
|
|
std::this_thread::sleep_for(1s);
|
|
}
|
|
|
|
protected:
|
|
std::unique_ptr<DeviceManager> device_manager_;
|
|
std::shared_ptr<MockDeviceEventListener> event_listener_;
|
|
};
|
|
|
|
// 测试设备管理器初始化
|
|
TEST_F(DeviceManagerTest, Initialization) {
|
|
// 初始化前状态
|
|
EXPECT_FALSE(device_manager_->is_initialized());
|
|
|
|
// 初始化
|
|
auto result = device_manager_->initialize();
|
|
|
|
// 验证初始化成功
|
|
EXPECT_EQ(result, common::ErrorCode::Success);
|
|
EXPECT_TRUE(device_manager_->is_initialized());
|
|
|
|
// 关闭
|
|
result = device_manager_->shutdown();
|
|
|
|
// 验证关闭成功
|
|
EXPECT_EQ(result, common::ErrorCode::Success);
|
|
EXPECT_FALSE(device_manager_->is_initialized());
|
|
}
|
|
|
|
// 测试设备枚举
|
|
TEST_F(DeviceManagerTest, DeviceEnumeration) {
|
|
// 初始化设备管理器
|
|
ASSERT_EQ(device_manager_->initialize(), common::ErrorCode::Success);
|
|
|
|
// 等待设备扫描完成
|
|
wait_for_device_scan();
|
|
|
|
// 获取所有设备
|
|
auto all_devices = device_manager_->get_all_devices();
|
|
|
|
// 获取输入设备
|
|
auto input_devices = device_manager_->get_input_devices();
|
|
|
|
// 获取输出设备
|
|
auto output_devices = device_manager_->get_output_devices();
|
|
|
|
// 验证设备列表
|
|
EXPECT_GE(all_devices.size(), input_devices.size() + output_devices.size());
|
|
|
|
// 验证输入设备类型
|
|
for (const auto& device : input_devices) {
|
|
EXPECT_TRUE(device.type == DeviceType::Input || device.type == DeviceType::Duplex);
|
|
}
|
|
|
|
// 验证输出设备类型
|
|
for (const auto& device : output_devices) {
|
|
EXPECT_TRUE(device.type == DeviceType::Output || device.type == DeviceType::Duplex);
|
|
}
|
|
|
|
// 获取默认输入设备
|
|
std::string default_input = device_manager_->get_default_input_device();
|
|
|
|
// 获取默认输出设备
|
|
std::string default_output = device_manager_->get_default_output_device();
|
|
|
|
// 如果有输入设备，默认输入设备不应为空
|
|
if (!input_devices.empty()) {
|
|
EXPECT_FALSE(default_input.empty());
|
|
}
|
|
|
|
// 如果有输出设备，默认输出设备不应为空
|
|
if (!output_devices.empty()) {
|
|
EXPECT_FALSE(default_output.empty());
|
|
}
|
|
|
|
// 检查设备详情
|
|
if (!all_devices.empty()) {
|
|
const auto& first_device = all_devices[0];
|
|
|
|
// 通过ID获取设备信息
|
|
auto device_info = device_manager_->get_device_info(first_device.id);
|
|
EXPECT_TRUE(device_info.has_value());
|
|
EXPECT_EQ(device_info->id, first_device.id);
|
|
EXPECT_EQ(device_info->name, first_device.name);
|
|
}
|
|
}
|
|
|
|
// 测试设备配置
|
|
TEST_F(DeviceManagerTest, DeviceConfiguration) {
|
|
// 初始化设备管理器
|
|
ASSERT_EQ(device_manager_->initialize(), common::ErrorCode::Success);
|
|
|
|
// 等待设备扫描完成
|
|
wait_for_device_scan();
|
|
|
|
// 获取输出设备
|
|
auto output_devices = device_manager_->get_output_devices();
|
|
if (output_devices.empty()) {
|
|
GTEST_SKIP() << "没有可用的输出设备，跳过测试";
|
|
}
|
|
|
|
// 获取第一个输出设备
|
|
const auto& test_device = output_devices[0];
|
|
|
|
// 创建配置
|
|
DeviceConfiguration config = create_test_config(test_device.id);
|
|
|
|
// 期望配置事件回调
|
|
EXPECT_CALL(*event_listener_, on_device_config_changed(test_device.id, ::testing::_))
|
|
.Times(::testing::AtLeast(0));
|
|
|
|
// 配置设备
|
|
auto result = device_manager_->configure_device(config);
|
|
EXPECT_EQ(result, common::ErrorCode::Success);
|
|
|
|
// 获取设备配置
|
|
auto stored_config = device_manager_->get_device_configuration(test_device.id);
|
|
EXPECT_TRUE(stored_config.has_value());
|
|
|
|
// 验证配置
|
|
if (stored_config) {
|
|
EXPECT_EQ(stored_config->device_id, config.device_id);
|
|
EXPECT_EQ(stored_config->sample_rate, config.sample_rate);
|
|
EXPECT_EQ(stored_config->channels, config.channels);
|
|
EXPECT_EQ(stored_config->format, config.format);
|
|
EXPECT_EQ(stored_config->buffer_size, config.buffer_size);
|
|
EXPECT_EQ(stored_config->exclusive_mode, config.exclusive_mode);
|
|
EXPECT_FLOAT_EQ(stored_config->volume, config.volume);
|
|
EXPECT_EQ(stored_config->muted, config.muted);
|
|
}
|
|
|
|
// 修改音量
|
|
double new_volume = 0.5;
|
|
result = device_manager_->set_device_volume(test_device.id, new_volume);
|
|
EXPECT_EQ(result, common::ErrorCode::Success);
|
|
|
|
// 获取音量
|
|
double current_volume = 0.0;
|
|
result = device_manager_->get_device_volume(test_device.id, current_volume);
|
|
EXPECT_EQ(result, common::ErrorCode::Success);
|
|
EXPECT_FLOAT_EQ(current_volume, new_volume);
|
|
|
|
// 设置静音
|
|
bool new_mute = true;
|
|
result = device_manager_->set_device_mute(test_device.id, new_mute);
|
|
EXPECT_EQ(result, common::ErrorCode::Success);
|
|
|
|
// 获取静音状态
|
|
bool current_mute = false;
|
|
result = device_manager_->get_device_mute(test_device.id, current_mute);
|
|
EXPECT_EQ(result, common::ErrorCode::Success);
|
|
EXPECT_EQ(current_mute, new_mute);
|
|
}
|
|
|
|
// 测试音频流控制
|
|
TEST_F(DeviceManagerTest, AudioStreamControl) {
|
|
// 初始化设备管理器
|
|
ASSERT_EQ(device_manager_->initialize(), common::ErrorCode::Success);
|
|
|
|
// 等待设备扫描完成
|
|
wait_for_device_scan();
|
|
|
|
// 获取输入和输出设备
|
|
auto input_devices = device_manager_->get_input_devices();
|
|
auto output_devices = device_manager_->get_output_devices();
|
|
|
|
// 测试输入流
|
|
if (!input_devices.empty()) {
|
|
const auto& input_device = input_devices[0];
|
|
|
|
// 配置设备
|
|
DeviceConfiguration input_config = create_test_config(input_device.id);
|
|
ASSERT_EQ(device_manager_->configure_device(input_config), common::ErrorCode::Success);
|
|
|
|
// 期望音频数据回调
|
|
EXPECT_CALL(*event_listener_, on_audio_data_available(input_device.id, ::testing::_))
|
|
.Times(::testing::AtLeast(0));
|
|
|
|
// 启动输入流
|
|
auto result = device_manager_->start_input_stream(input_device.id);
|
|
EXPECT_EQ(result, common::ErrorCode::Success);
|
|
|
|
// 等待一些音频帧
|
|
std::this_thread::sleep_for(500ms);
|
|
|
|
// 读取音频数据
|
|
engine::AudioBuffer buffer(512, 2, engine::AudioFormat::FLOAT32);
|
|
result = device_manager_->read_audio_data(input_device.id, buffer, 100ms);
|
|
|
|
// 停止输入流
|
|
result = device_manager_->stop_input_stream(input_device.id);
|
|
EXPECT_EQ(result, common::ErrorCode::Success);
|
|
}
|
|
|
|
// 测试输出流
|
|
if (!output_devices.empty()) {
|
|
const auto& output_device = output_devices[0];
|
|
|
|
// 配置设备
|
|
DeviceConfiguration output_config = create_test_config(output_device.id);
|
|
ASSERT_EQ(device_manager_->configure_device(output_config), common::ErrorCode::Success);
|
|
|
|
// 启动输出流
|
|
auto result = device_manager_->start_output_stream(output_device.id);
|
|
EXPECT_EQ(result, common::ErrorCode::Success);
|
|
|
|
// 创建测试音频缓冲区
|
|
engine::AudioBuffer test_buffer(512, 2, engine::AudioFormat::FLOAT32);
|
|
|
|
// 填充音频数据
|
|
float* data = test_buffer.interleaved_data<float>();
|
|
for (size_t i = 0; i < 512 * 2; ++i) {
|
|
data[i] = 0.1f * std::sin(2.0f * M_PI * i / 100.0f);
|
|
}
|
|
|
|
// 写入音频数据
|
|
result = device_manager_->write_audio_data(output_device.id, test_buffer);
|
|
EXPECT_EQ(result, common::ErrorCode::Success);
|
|
|
|
// 等待一些音频帧
|
|
std::this_thread::sleep_for(500ms);
|
|
|
|
// 停止输出流
|
|
result = device_manager_->stop_output_stream(output_device.id);
|
|
EXPECT_EQ(result, common::ErrorCode::Success);
|
|
}
|
|
}
|
|
|
|
// 测试默认设备变更
|
|
TEST_F(DeviceManagerTest, DefaultDeviceChanges) {
|
|
// 初始化设备管理器
|
|
ASSERT_EQ(device_manager_->initialize(), common::ErrorCode::Success);
|
|
|
|
// 等待设备扫描完成
|
|
wait_for_device_scan();
|
|
|
|
// 获取输入和输出设备
|
|
auto input_devices = device_manager_->get_input_devices();
|
|
auto output_devices = device_manager_->get_output_devices();
|
|
|
|
// 测试输入设备变更
|
|
if (input_devices.size() >= 2) {
|
|
// 获取当前默认输入设备
|
|
std::string current_default = device_manager_->get_default_input_device();
|
|
|
|
// 找到一个不是默认的输入设备
|
|
std::string new_default;
|
|
for (const auto& device : input_devices) {
|
|
if (device.id != current_default) {
|
|
new_default = device.id;
|
|
break;
|
|
}
|
|
}
|
|
|
|
// 设置期望回调
|
|
EXPECT_CALL(*event_listener_, on_default_device_changed(DeviceType::Input, new_default))
|
|
.Times(::testing::AtLeast(0));
|
|
|
|
// 更改默认输入设备
|
|
auto result = device_manager_->set_default_input_device(new_default);
|
|
EXPECT_EQ(result, common::ErrorCode::Success);
|
|
|
|
// 验证更改
|
|
EXPECT_EQ(device_manager_->get_default_input_device(), new_default);
|
|
}
|
|
|
|
// 测试输出设备变更
|
|
if (output_devices.size() >= 2) {
|
|
// 获取当前默认输出设备
|
|
std::string current_default = device_manager_->get_default_output_device();
|
|
|
|
// 找到一个不是默认的输出设备
|
|
std::string new_default;
|
|
for (const auto& device : output_devices) {
|
|
if (device.id != current_default) {
|
|
new_default = device.id;
|
|
break;
|
|
}
|
|
}
|
|
|
|
// 设置期望回调
|
|
EXPECT_CALL(*event_listener_, on_default_device_changed(DeviceType::Output, new_default))
|
|
.Times(::testing::AtLeast(0));
|
|
|
|
// 更改默认输出设备
|
|
auto result = device_manager_->set_default_output_device(new_default);
|
|
EXPECT_EQ(result, common::ErrorCode::Success);
|
|
|
|
// 验证更改
|
|
EXPECT_EQ(device_manager_->get_default_output_device(), new_default);
|
|
}
|
|
}
|
|
|
|
// 测试设备统计信息
|
|
TEST_F(DeviceManagerTest, DeviceStatistics) {
|
|
// 初始化设备管理器
|
|
ASSERT_EQ(device_manager_->initialize(), common::ErrorCode::Success);
|
|
|
|
// 等待设备扫描完成
|
|
wait_for_device_scan();
|
|
|
|
// 获取输出设备
|
|
auto output_devices = device_manager_->get_output_devices();
|
|
if (output_devices.empty()) {
|
|
GTEST_SKIP() << "没有可用的输出设备，跳过测试";
|
|
}
|
|
|
|
const auto& output_device = output_devices[0];
|
|
|
|
// 配置设备
|
|
DeviceConfiguration output_config = create_test_config(output_device.id);
|
|
ASSERT_EQ(device_manager_->configure_device(output_config), common::ErrorCode::Success);
|
|
|
|
// 启动输出流
|
|
ASSERT_EQ(device_manager_->start_output_stream(output_device.id), common::ErrorCode::Success);
|
|
|
|
// 发送一些音频数据
|
|
for (int i = 0; i < 10; i++) {
|
|
// 创建测试音频缓冲区
|
|
engine::AudioBuffer test_buffer(512, 2, engine::AudioFormat::FLOAT32);
|
|
|
|
// 填充音频数据
|
|
float* data = test_buffer.interleaved_data<float>();
|
|
for (size_t j = 0; j < 512 * 2; ++j) {
|
|
data[j] = 0.1f * std::sin(2.0f * M_PI * j / 100.0f);
|
|
}
|
|
|
|
// 写入音频数据
|
|
ASSERT_EQ(device_manager_->write_audio_data(output_device.id, test_buffer), common::ErrorCode::Success);
|
|
|
|
std::this_thread::sleep_for(50ms);
|
|
}
|
|
|
|
// 停止输出流
|
|
ASSERT_EQ(device_manager_->stop_output_stream(output_device.id), common::ErrorCode::Success);
|
|
|
|
// 获取全局统计信息
|
|
const auto& stats = device_manager_->get_statistics();
|
|
|
|
// 验证帧处理计数
|
|
EXPECT_GT(stats.frames_processed.load(), 0);
|
|
|
|
// 获取设备特定统计信息
|
|
auto device_stats = device_manager_->get_device_statistics(output_device.id);
|
|
EXPECT_TRUE(device_stats.has_value());
|
|
|
|
if (device_stats) {
|
|
EXPECT_GT(device_stats->frames_processed.load(), 0);
|
|
}
|
|
|
|
// 重置统计信息
|
|
device_manager_->reset_statistics();
|
|
|
|
// 验证统计信息已重置
|
|
const auto& reset_stats = device_manager_->get_statistics();
|
|
EXPECT_EQ(reset_stats.frames_processed.load(), 0);
|
|
EXPECT_EQ(reset_stats.buffer_underruns.load(), 0);
|
|
EXPECT_EQ(reset_stats.buffer_overruns.load(), 0);
|
|
}
|
|
|
|
// 测试设备管理器配置更新
|
|
TEST_F(DeviceManagerTest, ConfigUpdate) {
|
|
// 初始化设备管理器
|
|
ASSERT_EQ(device_manager_->initialize(), common::ErrorCode::Success);
|
|
|
|
// 获取当前配置
|
|
const auto& initial_config = device_manager_->config();
|
|
|
|
// 创建新配置
|
|
DeviceManagerConfig new_config = initial_config;
|
|
new_config.default_buffer_size = 1024; // 修改缓冲区大小
|
|
new_config.device_scan_interval_ms = 2000; // 修改扫描间隔
|
|
|
|
// 更新配置
|
|
auto result = device_manager_->update_config(new_config);
|
|
EXPECT_EQ(result, common::ErrorCode::Success);
|
|
|
|
// 验证配置更新
|
|
const auto& updated_config = device_manager_->config();
|
|
EXPECT_EQ(updated_config.default_buffer_size, 1024);
|
|
EXPECT_EQ(updated_config.device_scan_interval_ms, 2000);
|
|
}
|
|
|
|
// 测试设备工厂方法
|
|
TEST_F(DeviceManagerTest, DeviceFactory) {
|
|
// 获取系统推荐配置
|
|
auto recommended_config = device_factory::get_recommended_config();
|
|
|
|
// 验证推荐配置的合理性
|
|
EXPECT_GE(recommended_config.default_buffer_size, 64);
|
|
EXPECT_LE(recommended_config.default_buffer_size, 8192);
|
|
|
|
// 获取可用的驱动
|
|
auto available_drivers = device_factory::detect_available_drivers();
|
|
|
|
// 验证至少有一个可用的驱动
|
|
EXPECT_FALSE(available_drivers.empty());
|
|
|
|
// 验证驱动类型有效
|
|
for (auto driver : available_drivers) {
|
|
EXPECT_NE(driver, DeviceDriver::Unknown);
|
|
}
|
|
}
|
|
|
|
int main(int argc, char** argv) {
|
|
::testing::InitGoogleTest(&argc, argv);
|
|
return RUN_ALL_TESTS();
|
|
} |