247 lines
8.1 KiB
C++
247 lines
8.1 KiB
C++
// ================================================================================================
|
||
// Audio Backend - 通信消息测试
|
||
// ================================================================================================
|
||
|
||
#include <gtest/gtest.h>
|
||
#include <gmock/gmock.h>
|
||
#include "communication/core/message.h"
|
||
#include "tests/common/test_fixtures.h"
|
||
|
||
using namespace audio_backend;
|
||
using namespace audio_backend::communication;
|
||
|
||
// 自定义测试消息类
|
||
class TestMessageImpl : public Message {
|
||
public:
|
||
TestMessageImpl(const std::string& content = "")
|
||
: Message("TestMessage"), content_(content) {}
|
||
|
||
void set_content(const std::string& content) { content_ = content; }
|
||
const std::string& content() const { return content_; }
|
||
|
||
// 实现虚函数
|
||
size_t estimated_size() const override { return sizeof(*this) + content_.size(); }
|
||
Priority priority() const override { return Priority::Normal; }
|
||
TransportChannel preferred_channel() const override { return TransportChannel::ZeroMQ; }
|
||
|
||
private:
|
||
std::string content_;
|
||
};
|
||
|
||
// 消息测试固定装置
|
||
class MessageTest : public test::CommunicationTest {
|
||
protected:
|
||
void SetUp() override {
|
||
test::CommunicationTest::SetUp();
|
||
}
|
||
|
||
void TearDown() override {
|
||
test::CommunicationTest::TearDown();
|
||
}
|
||
};
|
||
|
||
// 测试基本消息属性
|
||
TEST_F(MessageTest, BasicAttributes) {
|
||
// 创建测试消息
|
||
TestMessageImpl message("测试内容");
|
||
|
||
// 验证基本属性
|
||
EXPECT_EQ(message.message_type(), "TestMessage");
|
||
EXPECT_EQ(message.content(), "测试内容");
|
||
EXPECT_EQ(message.priority(), Message::Priority::Normal);
|
||
EXPECT_EQ(message.preferred_channel(), Message::TransportChannel::ZeroMQ);
|
||
EXPECT_GT(message.estimated_size(), sizeof(message));
|
||
|
||
// 验证时间戳
|
||
EXPECT_GT(message.timestamp().time_since_epoch().count(), 0);
|
||
|
||
// 验证唯一ID
|
||
EXPECT_FALSE(message.message_id().empty());
|
||
}
|
||
|
||
// 测试消息修改
|
||
TEST_F(MessageTest, Modification) {
|
||
// 创建测试消息
|
||
TestMessageImpl message("原始内容");
|
||
EXPECT_EQ(message.content(), "原始内容");
|
||
|
||
// 修改内容
|
||
message.set_content("内容");
|
||
EXPECT_EQ(message.content(), "新内容");
|
||
}
|
||
|
||
// 测试消息ID唯一性
|
||
TEST_F(MessageTest, UniqueIds) {
|
||
const int message_count = 100;
|
||
std::set<std::string> ids;
|
||
|
||
// 创建多个消息，验证ID唯一性
|
||
for (int i = 0; i < message_count; ++i) {
|
||
TestMessageImpl message(std::to_string(i));
|
||
ids.insert(message.message_id());
|
||
}
|
||
|
||
// 验证所有ID都是唯的
|
||
EXPECT_EQ(ids.size(), message_count);
|
||
}
|
||
|
||
// 测试消息复制
|
||
TEST_F(MessageTest, MessageCloning) {
|
||
// 创建原始消息
|
||
TestMessageImpl original("原始消息");
|
||
|
||
// 克隆消息
|
||
std::unique_ptr<IMessage> cloned = original.clone();
|
||
|
||
// 验证是否正确克隆
|
||
EXPECT_NE(cloned.get(), nullptr);
|
||
EXPECT_EQ(cloned->message_type(), original.message_type());
|
||
|
||
// 转换为具体类型并验证内容
|
||
TestMessageImpl* cloned_typed = dynamic_cast<TestMessageImpl*>(cloned.get());
|
||
ASSERT_NE(cloned_typed, nullptr);
|
||
EXPECT_EQ(cloned_typed->content(), "原始消息");
|
||
|
||
// 验证ID和时间戳是立的
|
||
EXPECT_NE(cloned_typed->message_id(), original.message_id());
|
||
// 时间戳可能相同或不同，取决于实现，这里不做严格要求
|
||
}
|
||
|
||
// 测试不同优先级消息
|
||
class PriorityMessage : public Message {
|
||
public:
|
||
enum class TestPriority {
|
||
Low, Normal, High, Critical
|
||
};
|
||
|
||
PriorityMessage(TestPriority priority)
|
||
: Message("PriorityMessage"), test_priority_(priority) {}
|
||
|
||
// 实现虚函数
|
||
size_t estimated_size() const override { return sizeof(*this); }
|
||
|
||
Priority priority() const override {
|
||
switch (test_priority_) {
|
||
case TestPriority::Low:
|
||
return Priority::Low;
|
||
case TestPriority::Normal:
|
||
return Priority::Normal;
|
||
case TestPriority::High:
|
||
return Priority::High;
|
||
case TestPriority::Critical:
|
||
return Priority::Critical;
|
||
default:
|
||
return Priority::Normal;
|
||
}
|
||
}
|
||
|
||
TransportChannel preferred_channel() const override { return TransportChannel::ZeroMQ; }
|
||
|
||
private:
|
||
TestPriority test_priority_;
|
||
};
|
||
|
||
TEST_F(MessageTest, MessagePriorities) {
|
||
// 创建不同优先级的消息
|
||
PriorityMessage low_msg(PriorityMessage::TestPriority::Low);
|
||
PriorityMessage normal_msg(PriorityMessage::TestPriority::Normal);
|
||
PriorityMessage high_msg(PriorityMessage::TestPriority::High);
|
||
PriorityMessage critical_msg(PriorityMessage::TestPriority::Critical);
|
||
|
||
// 验证优先级
|
||
EXPECT_EQ(low_msg.priority(), Message::Priority::Low);
|
||
EXPECT_EQ(normal_msg.priority(), Message::Priority::Normal);
|
||
EXPECT_EQ(high_msg.priority(), Message::Priority::High);
|
||
EXPECT_EQ(critical_msg.priority(), Message::Priority::Critical);
|
||
|
||
// 验证优先级比较
|
||
EXPECT_LT(static_cast<int>(low_msg.priority()), static_cast<int>(normal_msg.priority()));
|
||
EXPECT_LT(static_cast<int>(normal_msg.priority()), static_cast<int>(high_msg.priority()));
|
||
EXPECT_LT(static_cast<int>(high_msg.priority()), static_cast<int>(critical_msg.priority()));
|
||
}
|
||
|
||
// 测试不同传输通道
|
||
class TransportChannelMessage : public Message {
|
||
public:
|
||
enum class TestChannel {
|
||
ZeroMQ, SharedMemory, Direct, Auto
|
||
};
|
||
|
||
TransportChannelMessage(TestChannel channel)
|
||
: Message("ChannelMessage"), test_channel_(channel) {}
|
||
|
||
// 实现虚函数
|
||
size_t estimated_size() const override { return sizeof(*this); }
|
||
Priority priority() const override { return Priority::Normal; }
|
||
|
||
TransportChannel preferred_channel() const override {
|
||
switch (test_channel_) {
|
||
case TestChannel::ZeroMQ:
|
||
return TransportChannel::ZeroMQ;
|
||
case TestChannel::SharedMemory:
|
||
return TransportChannel::SharedMemory;
|
||
case TestChannel::Direct:
|
||
return TransportChannel::Direct;
|
||
case TestChannel::Auto:
|
||
return TransportChannel::Auto;
|
||
default:
|
||
return TransportChannel::Auto;
|
||
}
|
||
}
|
||
|
||
private:
|
||
TestChannel test_channel_;
|
||
};
|
||
|
||
TEST_F(MessageTest, MessageChannels) {
|
||
// 创建不同通道的消息
|
||
TransportChannelMessage zmq_msg(TransportChannelMessage::TestChannel::ZeroMQ);
|
||
TransportChannelMessage shm_msg(TransportChannelMessage::TestChannel::SharedMemory);
|
||
TransportChannelMessage direct_msg(TransportChannelMessage::TestChannel::Direct);
|
||
TransportChannelMessage auto_msg(TransportChannelMessage::TestChannel::Auto);
|
||
|
||
// 验证通道
|
||
EXPECT_EQ(zmq_msg.preferred_channel(), Message::TransportChannel::ZeroMQ);
|
||
EXPECT_EQ(shm_msg.preferred_channel(), Message::TransportChannel::SharedMemory);
|
||
EXPECT_EQ(direct_msg.preferred_channel(), Message::TransportChannel::Direct);
|
||
EXPECT_EQ(auto_msg.preferred_channel(), Message::TransportChannel::Auto);
|
||
}
|
||
|
||
// 测试消息工厂
|
||
TEST_F(MessageTest, MessageFactoryRegistration) {
|
||
// 创建消息工厂
|
||
MessageFactory factory;
|
||
|
||
// 注册测试消息
|
||
factory.register_message<TestMessageImpl>("TestMessage");
|
||
|
||
// 创建消息
|
||
auto message = factory.create_message("TestMessage");
|
||
|
||
// 验证是否正确创建
|
||
EXPECT_NE(message.get(), nullptr);
|
||
EXPECT_EQ(message->message_type(), "TestMessage");
|
||
|
||
// 转换为具体类型
|
||
auto* typed_message = dynamic_cast<TestMessageImpl*>(message.get());
|
||
EXPECT_NE(typed_message, nullptr);
|
||
}
|
||
|
||
// 测试消息序列化与反序列化接口
|
||
TEST_F(MessageTest, SerializationInterface) {
|
||
// 创建测试消息
|
||
TestMessageImpl message("要序列化内容");
|
||
|
||
// 模拟序列化
|
||
std::vector<uint8_t> serialized_data;
|
||
size_t expected_size = message.estimated_size();
|
||
|
||
// 验证预估大小合理性
|
||
EXPECT_GT(expected_size, sizeof(message));
|
||
EXPECT_GT(expected_size, message.content().size());
|
||
}
|
||
|
||
int main(int argc, char** argv) {
|
||
::testing::InitGoogleTest(&argc, argv);
|
||
return RUN_ALL_TESTS();
|
||
} |