1100 lines
43 KiB
C++
1100 lines
43 KiB
C++
// XYParser API 单元测试文件
|
||
// 测试 XYParser 库的核心功能，包括解析器创建、错误处理、帧解析等
|
||
|
||
#include <gtest/gtest.h>
|
||
#include "../XYParserApi.h"
|
||
|
||
#include <algorithm>
|
||
#include <array>
|
||
#include <cstddef>
|
||
#include <cstdint>
|
||
#include <cmath>
|
||
#include <string>
|
||
#include <vector>
|
||
|
||
// 匿名命名空间，包含测试辅助代码
|
||
namespace {
|
||
|
||
/// ParserGuard 类：RAII 封装，确保解析器资源自动释放
|
||
/// 当对象生命周期结束时自动调用 XYParser_DestroyParser 释放资源
|
||
class ParserGuard {
|
||
public:
|
||
/// 构造函数，接管解析器句柄的所有权
|
||
/// @param handle XYParser 解析器句柄
|
||
explicit ParserGuard(XYParserHandle handle) : handle_(handle) {}
|
||
|
||
/// 析构函数，自动释放解析器资源
|
||
~ParserGuard()
|
||
{
|
||
if (handle_ != nullptr) {
|
||
XYParser_DestroyParser(handle_);
|
||
}
|
||
}
|
||
|
||
/// 获取解析器句柄
|
||
/// @return XYParser 解析器句柄
|
||
XYParserHandle get() const
|
||
{
|
||
return handle_;
|
||
}
|
||
|
||
private:
|
||
XYParserHandle handle_; ///< 解析器句柄
|
||
};
|
||
|
||
/// 构建最小帧数据的辅助函数
|
||
/// 生成符合 XYParser 协议格式的测试帧数据
|
||
/// @param channel_count 通道数量
|
||
/// @param frame_index 帧索引，小端写入标签区前 4 字节
|
||
/// @return 包含完整帧数据的字节向量
|
||
std::vector<std::uint8_t> BuildMinimalFrame(std::uint8_t channel_count, std::uint32_t frame_index)
|
||
{
|
||
constexpr std::size_t kSamplesPerFrame = 5; ///< 每帧采样数
|
||
constexpr std::uint8_t kHeader = 0xAA; ///< 帧头标记
|
||
constexpr std::uint8_t kTail = 0x55; ///< 帧尾标记
|
||
constexpr std::size_t kTagLen = 25; ///< 标签长度
|
||
|
||
// 计算帧结构大小
|
||
const std::size_t sample_bytes = static_cast<std::size_t>(channel_count) * 3 + 2;
|
||
const std::uint16_t payload_length = static_cast<std::uint16_t>(sample_bytes * kSamplesPerFrame);
|
||
const std::size_t frame_size = 1 + kTagLen + payload_length + 2;
|
||
|
||
std::vector<std::uint8_t> frame(frame_size, 0);
|
||
std::size_t offset = 0;
|
||
|
||
// 写入帧头
|
||
frame[offset++] = kHeader;
|
||
|
||
// 写入标签数据中的帧索引（小端序）
|
||
frame[offset++] = static_cast<std::uint8_t>(frame_index & 0xFF);
|
||
frame[offset++] = static_cast<std::uint8_t>((frame_index >> 8) & 0xFF);
|
||
frame[offset++] = static_cast<std::uint8_t>((frame_index >> 16) & 0xFF);
|
||
frame[offset++] = static_cast<std::uint8_t>((frame_index >> 24) & 0xFF);
|
||
|
||
// 写入负载长度（大端序）
|
||
frame[offset++] = static_cast<std::uint8_t>((payload_length >> 8) & 0xFF);
|
||
frame[offset++] = static_cast<std::uint8_t>(payload_length & 0xFF);
|
||
|
||
// 写入电池电量和通道数
|
||
frame[offset++] = 95;
|
||
frame[offset++] = channel_count;
|
||
|
||
// 跳过保留字段
|
||
offset += 2 + 2 + 2 + 2 + 2 + 6;
|
||
|
||
// 写入采样数据
|
||
for (std::size_t sample = 0; sample < kSamplesPerFrame; ++sample) {
|
||
for (std::size_t channel = 0; channel < channel_count; ++channel) {
|
||
frame[offset++] = 0x00;
|
||
frame[offset++] = 0x00;
|
||
frame[offset++] = static_cast<std::uint8_t>(sample + channel + 1);
|
||
}
|
||
// 每个采样后的额外字节
|
||
frame[offset++] = 0x00;
|
||
frame[offset++] = 0x00;
|
||
}
|
||
|
||
// 写入帧尾
|
||
frame[offset++] = 0x00;
|
||
frame[offset++] = kTail;
|
||
frame[offset++] = kTail;
|
||
|
||
return frame;
|
||
}
|
||
|
||
/// 为现有调用点保留默认 frame_index=1 的便捷重载
|
||
std::vector<std::uint8_t> BuildMinimalFrame(std::uint8_t channel_count)
|
||
{
|
||
return BuildMinimalFrame(channel_count, 1U);
|
||
}
|
||
|
||
void WriteSigned24(std::vector<std::uint8_t>& frame, std::size_t& offset, int raw_value)
|
||
{
|
||
constexpr int kMinSigned24 = -8388608;
|
||
constexpr int kMaxSigned24 = 8388607;
|
||
raw_value = std::max(kMinSigned24, std::min(kMaxSigned24, raw_value));
|
||
std::uint32_t encoded = 0;
|
||
if (raw_value < 0) {
|
||
encoded = static_cast<std::uint32_t>((1 << 24) + raw_value);
|
||
} else {
|
||
encoded = static_cast<std::uint32_t>(raw_value);
|
||
}
|
||
|
||
frame[offset++] = static_cast<std::uint8_t>((encoded >> 16) & 0xFF);
|
||
frame[offset++] = static_cast<std::uint8_t>((encoded >> 8) & 0xFF);
|
||
frame[offset++] = static_cast<std::uint8_t>(encoded & 0xFF);
|
||
}
|
||
|
||
std::vector<std::uint8_t> BuildFrameWithRawSamples(
|
||
std::uint8_t channel_count,
|
||
std::uint32_t frame_index,
|
||
const std::array<std::array<int, XYPARSER_MAX_CHANNELS>, XYPARSER_SAMPLES_PER_FRAME>& raw_samples)
|
||
{
|
||
constexpr std::uint8_t kHeader = 0xAA;
|
||
constexpr std::uint8_t kTail = 0x55;
|
||
constexpr std::size_t kTagLen = 25;
|
||
|
||
const std::size_t sample_bytes = static_cast<std::size_t>(channel_count) * 3 + 2;
|
||
const std::uint16_t payload_length = static_cast<std::uint16_t>(sample_bytes * XYPARSER_SAMPLES_PER_FRAME);
|
||
const std::size_t frame_size = 1 + kTagLen + payload_length + 2;
|
||
|
||
std::vector<std::uint8_t> frame(frame_size, 0);
|
||
std::size_t offset = 0;
|
||
frame[offset++] = kHeader;
|
||
frame[offset++] = static_cast<std::uint8_t>(frame_index & 0xFF);
|
||
frame[offset++] = static_cast<std::uint8_t>((frame_index >> 8) & 0xFF);
|
||
frame[offset++] = static_cast<std::uint8_t>((frame_index >> 16) & 0xFF);
|
||
frame[offset++] = static_cast<std::uint8_t>((frame_index >> 24) & 0xFF);
|
||
frame[offset++] = static_cast<std::uint8_t>((payload_length >> 8) & 0xFF);
|
||
frame[offset++] = static_cast<std::uint8_t>(payload_length & 0xFF);
|
||
frame[offset++] = 95;
|
||
frame[offset++] = channel_count;
|
||
offset += 2 + 2 + 2 + 2 + 2 + 6;
|
||
|
||
for (std::size_t sample = 0; sample < XYPARSER_SAMPLES_PER_FRAME; ++sample) {
|
||
for (std::size_t channel = 0; channel < channel_count; ++channel) {
|
||
WriteSigned24(frame, offset, raw_samples[sample][channel]);
|
||
}
|
||
frame[offset++] = 0x00;
|
||
frame[offset++] = 0x00;
|
||
}
|
||
|
||
frame[offset++] = 0x00;
|
||
frame[offset++] = kTail;
|
||
frame[offset++] = kTail;
|
||
return frame;
|
||
}
|
||
|
||
int BuildSineRawValue(int sample_index, int sample_rate, double frequency_hz, double amplitude)
|
||
{
|
||
const double angle = 2.0 * 3.14159265358979323846 * frequency_hz *
|
||
static_cast<double>(sample_index) / static_cast<double>(sample_rate);
|
||
return static_cast<int>(std::lround(std::sin(angle) * amplitude));
|
||
}
|
||
|
||
} // namespace
|
||
|
||
/// 测试：创建解析器时拒绝不支持的通道数
|
||
TEST(XYParserApiTests, CreateParserRejectsUnsupportedChannelCount)
|
||
{
|
||
// 7 通道是不支持的配置，应返回 nullptr
|
||
EXPECT_EQ(XYParser_CreateParser(7), nullptr);
|
||
}
|
||
|
||
/// 测试：对空解析器句柄调用 GetLastError 应返回正确错误信息
|
||
TEST(XYParserApiTests, GetLastErrorReturnsMessageForNullParser)
|
||
{
|
||
// 传入 nullptr 应返回 "invalid parser handle"
|
||
EXPECT_EQ(std::string(XYParser_GetLastError(nullptr)), std::string("invalid parser handle"));
|
||
}
|
||
|
||
TEST(XYParserApiTests, Serialize8ChImpedanceOpenCommandMatchesWirelessEegPacket)
|
||
{
|
||
constexpr std::size_t kCommandSize = 7;
|
||
std::array<std::uint8_t, kCommandSize> command{};
|
||
const int command_size = XYParser_Serialize8ChImpedanceCommand(1, command.data(), command.size());
|
||
|
||
ASSERT_EQ(command_size, static_cast<int>(kCommandSize));
|
||
const std::array<std::uint8_t, kCommandSize> expected = {
|
||
0xAA, 0x00, 0x01, 0xA1, 0xA1, 0x55, 0x55};
|
||
EXPECT_EQ(command, expected);
|
||
}
|
||
|
||
TEST(XYParserApiTests, Serialize8ChImpedanceCloseCommandMatchesWirelessEegPacket)
|
||
{
|
||
constexpr std::size_t kCommandSize = 7;
|
||
std::array<std::uint8_t, kCommandSize> command{};
|
||
const int command_size = XYParser_Serialize8ChImpedanceCommand(0, command.data(), command.size());
|
||
|
||
ASSERT_EQ(command_size, static_cast<int>(kCommandSize));
|
||
const std::array<std::uint8_t, kCommandSize> expected = {
|
||
0xAA, 0x00, 0x01, 0xA0, 0xA0, 0x55, 0x55};
|
||
EXPECT_EQ(command, expected);
|
||
}
|
||
|
||
TEST(XYParserApiTests, Serialize8ChImpedanceCommandRejectsSmallBuffer)
|
||
{
|
||
std::array<std::uint8_t, 6> command{};
|
||
EXPECT_EQ(XYParser_Serialize8ChImpedanceCommand(1, command.data(), command.size()), 0);
|
||
}
|
||
|
||
TEST(XYParserApiTests, Get8ChImpedanceCommandSizeMatchesSerializedLength)
|
||
{
|
||
EXPECT_EQ(XYParser_Get8ChImpedanceCommandSize(), static_cast<std::size_t>(7));
|
||
}
|
||
|
||
TEST(XYParserApiTests, GetAlgorithmDataValueCountMatchesFrameLayout)
|
||
{
|
||
EXPECT_EQ(XYParser_GetAlgorithmDataValueCount(),
|
||
static_cast<std::size_t>(XYPARSER_FRAME_ALGORITHM_VALUE_COUNT));
|
||
}
|
||
|
||
TEST(XYParserApiTests, GetLeadMapCountReturnsExpectedCounts)
|
||
{
|
||
EXPECT_EQ(XYParser_GetLeadMapCount(8), 8);
|
||
EXPECT_EQ(XYParser_GetLeadMapCount(64), 64);
|
||
EXPECT_EQ(XYParser_GetLeadMapCount(7), 0);
|
||
}
|
||
|
||
TEST(XYParserApiTests, GetLeadMapReturnsExpected8ChannelSubset)
|
||
{
|
||
std::array<XYParserLeadChannelNumber, 8> leads{};
|
||
const int count = XYParser_GetLeadMap(8, leads.data(), static_cast<int>(leads.size()));
|
||
|
||
ASSERT_EQ(count, 8);
|
||
const std::array<XYParserLeadChannelNumber, 8> expected = {
|
||
LeadChannel_PO5, LeadChannel_POZ, LeadChannel_PO6, LeadChannel_PO7,
|
||
LeadChannel_O1, LeadChannel_OZ, LeadChannel_O2, LeadChannel_PO8};
|
||
EXPECT_EQ(leads, expected);
|
||
}
|
||
|
||
TEST(XYParserApiTests, GetLeadMapReturnsExpected64ChannelOrder)
|
||
{
|
||
std::array<XYParserLeadChannelNumber, 64> leads{};
|
||
const int count = XYParser_GetLeadMap(64, leads.data(), static_cast<int>(leads.size()));
|
||
|
||
ASSERT_EQ(count, 64);
|
||
EXPECT_EQ(leads.front(), LeadChannel_FP1);
|
||
EXPECT_EQ(leads[1], LeadChannel_FP2);
|
||
EXPECT_EQ(leads[13], LeadChannel_PO5);
|
||
EXPECT_EQ(leads[55], LeadChannel_PO7);
|
||
EXPECT_EQ(leads.back(), LeadChannel_F1);
|
||
}
|
||
|
||
TEST(XYParserApiTests, GetLeadMapRejectsUnsupportedChannelCountOrSmallBuffer)
|
||
{
|
||
std::array<XYParserLeadChannelNumber, 7> small_buffer{};
|
||
EXPECT_EQ(XYParser_GetLeadMap(8, small_buffer.data(), static_cast<int>(small_buffer.size())), 0);
|
||
EXPECT_EQ(XYParser_GetLeadMap(7, nullptr, 0), 0);
|
||
}
|
||
|
||
TEST(XYParserApiTests, Convert8ChFramesTo64ChMapsKnownLeadsAndPadsOthersWithZero)
|
||
{
|
||
std::array<XYParserFrameSummary, 2> input{};
|
||
input[0].frame_index = 7U;
|
||
input[0].channel_count = 8U;
|
||
input[0].battery = 88U;
|
||
input[0].sample_count = 5U;
|
||
input[0].sample_trigger_types[0] = 0xB2;
|
||
input[0].sample_trigger_indices[0] = 3U;
|
||
input[0].channel_values_uv[0][0] = 11.0;
|
||
input[0].channel_values_uv[0][1] = 12.0;
|
||
input[0].channel_values_uv[0][2] = 13.0;
|
||
input[0].channel_values_uv[0][3] = 14.0;
|
||
input[0].channel_values_uv[0][4] = 15.0;
|
||
input[0].channel_values_uv[0][5] = 16.0;
|
||
input[0].channel_values_uv[0][6] = 17.0;
|
||
input[0].channel_values_uv[0][7] = 18.0;
|
||
|
||
input[1].frame_index = 8U;
|
||
input[1].channel_count = 8U;
|
||
input[1].battery = 77U;
|
||
input[1].sample_count = 5U;
|
||
input[1].channel_values_uv[1][0] = 21.0;
|
||
|
||
std::array<XYParserFrameSummary, 2> output{};
|
||
ASSERT_EQ(XYParser_Convert8ChFramesTo64Ch(input.data(), static_cast<int>(input.size()), output.data(), static_cast<int>(output.size())), 2);
|
||
EXPECT_EQ(output[0].frame_index, 7U);
|
||
EXPECT_EQ(output[0].channel_count, 64U);
|
||
EXPECT_EQ(output[0].battery, 88U);
|
||
EXPECT_EQ(output[0].sample_count, 5U);
|
||
EXPECT_EQ(output[0].sample_trigger_types[0], 0xB2);
|
||
EXPECT_EQ(output[0].sample_trigger_indices[0], 3U);
|
||
EXPECT_DOUBLE_EQ(output[0].channel_values_uv[0][LeadChannel_PO5], 11.0);
|
||
EXPECT_DOUBLE_EQ(output[0].channel_values_uv[0][LeadChannel_POZ], 12.0);
|
||
EXPECT_DOUBLE_EQ(output[0].channel_values_uv[0][LeadChannel_PO6], 13.0);
|
||
EXPECT_DOUBLE_EQ(output[0].channel_values_uv[0][LeadChannel_PO7], 14.0);
|
||
EXPECT_DOUBLE_EQ(output[0].channel_values_uv[0][LeadChannel_O1], 15.0);
|
||
EXPECT_DOUBLE_EQ(output[0].channel_values_uv[0][LeadChannel_OZ], 16.0);
|
||
EXPECT_DOUBLE_EQ(output[0].channel_values_uv[0][LeadChannel_O2], 17.0);
|
||
EXPECT_DOUBLE_EQ(output[0].channel_values_uv[0][LeadChannel_PO8], 18.0);
|
||
EXPECT_DOUBLE_EQ(output[0].channel_values_uv[0][LeadChannel_FP1], 0.0);
|
||
EXPECT_DOUBLE_EQ(output[0].channel_values_uv[0][LeadChannel_CZ], 0.0);
|
||
EXPECT_EQ(output[1].frame_index, 8U);
|
||
EXPECT_EQ(output[1].channel_count, 64U);
|
||
EXPECT_DOUBLE_EQ(output[1].channel_values_uv[1][LeadChannel_PO5], 21.0);
|
||
}
|
||
|
||
TEST(XYParserApiTests, Convert8ChFramesTo64ChRejectsInvalidArgumentsAndStopsAtNon8ChannelInput)
|
||
{
|
||
std::array<XYParserFrameSummary, 2> input{};
|
||
input[0].channel_count = 8U;
|
||
input[1].channel_count = 64U;
|
||
std::array<XYParserFrameSummary, 2> output{};
|
||
|
||
EXPECT_EQ(XYParser_Convert8ChFramesTo64Ch(nullptr, 1, output.data(), static_cast<int>(output.size())), 0);
|
||
EXPECT_EQ(XYParser_Convert8ChFramesTo64Ch(input.data(), 1, nullptr, static_cast<int>(output.size())), 0);
|
||
EXPECT_EQ(XYParser_Convert8ChFramesTo64Ch(input.data(), 0, output.data(), static_cast<int>(output.size())), 0);
|
||
EXPECT_EQ(XYParser_Convert8ChFramesTo64Ch(input.data(), static_cast<int>(input.size()), output.data(), static_cast<int>(output.size())), 1);
|
||
EXPECT_EQ(output[0].channel_count, 64U);
|
||
}
|
||
|
||
TEST(XYParserApiTests, ConvertSampleFramesToAlgorithmDataAppendsTriggerColumnsPerSample)
|
||
{
|
||
constexpr std::size_t kFrameValueCount = XYPARSER_FRAME_ALGORITHM_VALUE_COUNT;
|
||
XYParserFrameSummary input{};
|
||
input.channel_count = 64U;
|
||
input.sample_count = 5U;
|
||
input.channel_values_uv[0][0] = 101.0;
|
||
input.channel_values_uv[0][63] = 164.0;
|
||
input.sample_trigger_types[0] = 0xA5;
|
||
input.sample_trigger_indices[0] = 9U;
|
||
input.channel_values_uv[1][10] = 210.0;
|
||
input.sample_trigger_types[1] = 0x7F;
|
||
input.sample_trigger_indices[1] = 5U;
|
||
input.channel_values_uv[4][3] = 403.0;
|
||
input.sample_trigger_types[4] = 0xB2;
|
||
input.sample_trigger_indices[4] = 11U;
|
||
|
||
std::array<double, kFrameValueCount> output{};
|
||
ASSERT_EQ(XYParser_ConvertSampleFramesToAlgorithmData(&input, output.data()), 1);
|
||
|
||
const std::size_t sample0 = 0;
|
||
const std::size_t sample1 = XYPARSER_FRAME_DATA_COLUMN_COUNT;
|
||
const std::size_t sample4 = 4 * XYPARSER_FRAME_DATA_COLUMN_COUNT;
|
||
|
||
EXPECT_DOUBLE_EQ(output[sample0 + 0], 101.0);
|
||
EXPECT_DOUBLE_EQ(output[sample0 + 63], 164.0);
|
||
EXPECT_DOUBLE_EQ(output[sample0 + XYPARSER_FRAME_DATA_TRIGGER_TYPE_INDEX], 165.0);
|
||
EXPECT_DOUBLE_EQ(output[sample0 + XYPARSER_FRAME_DATA_TRIGGER_INDEX_INDEX], 9.0);
|
||
EXPECT_DOUBLE_EQ(output[sample4 + 3], 403.0);
|
||
EXPECT_DOUBLE_EQ(output[sample4 + XYPARSER_FRAME_DATA_TRIGGER_TYPE_INDEX], 178.0);
|
||
EXPECT_DOUBLE_EQ(output[sample4 + XYPARSER_FRAME_DATA_TRIGGER_INDEX_INDEX], 11.0);
|
||
EXPECT_DOUBLE_EQ(output[sample1 + 10], 210.0);
|
||
EXPECT_DOUBLE_EQ(output[sample1 + XYPARSER_FRAME_DATA_TRIGGER_TYPE_INDEX], 127.0);
|
||
EXPECT_DOUBLE_EQ(output[sample1 + XYPARSER_FRAME_DATA_TRIGGER_INDEX_INDEX], 5.0);
|
||
}
|
||
|
||
TEST(XYParserApiTests, ConvertSampleFramesToAlgorithmDataRejectsInvalidArgumentsAndNon64ChannelInput)
|
||
{
|
||
constexpr std::size_t kFrameValueCount = XYPARSER_FRAME_ALGORITHM_VALUE_COUNT;
|
||
XYParserFrameSummary input{};
|
||
input.channel_count = 8U;
|
||
std::array<double, kFrameValueCount> output{};
|
||
|
||
EXPECT_EQ(XYParser_ConvertSampleFramesToAlgorithmData(nullptr, output.data()), 0);
|
||
EXPECT_EQ(XYParser_ConvertSampleFramesToAlgorithmData(&input, nullptr), 0);
|
||
EXPECT_EQ(XYParser_ConvertSampleFramesToAlgorithmData(&input, output.data()), 0);
|
||
EXPECT_DOUBLE_EQ(output[XYPARSER_FRAME_DATA_TRIGGER_TYPE_INDEX], 0.0);
|
||
}
|
||
|
||
TEST(XYParserApiTests, FeedAlgorithmDataCachesSamplesBuildsFramesAndFlushesTailSamples)
|
||
{
|
||
ParserGuard parser(XYParser_CreateParser(64));
|
||
ASSERT_NE(parser.get(), nullptr);
|
||
|
||
constexpr int kTotalSamples = 7;
|
||
constexpr int kColumnCount = XYPARSER_FRAME_DATA_COLUMN_COUNT;
|
||
std::array<double, static_cast<std::size_t>(kTotalSamples) * kColumnCount> input_data{};
|
||
for (int sample_index = 0; sample_index < kTotalSamples; ++sample_index) {
|
||
const std::size_t row_offset = static_cast<std::size_t>(sample_index) * kColumnCount;
|
||
input_data[row_offset + 0] = 1000.0 + sample_index;
|
||
input_data[row_offset + 10] = 2000.0 + sample_index;
|
||
input_data[row_offset + 63] = 3000.0 + sample_index;
|
||
input_data[row_offset + XYPARSER_FRAME_DATA_TRIGGER_TYPE_INDEX] = 10.0 + sample_index;
|
||
input_data[row_offset + XYPARSER_FRAME_DATA_TRIGGER_INDEX_INDEX] = 20.0 + sample_index;
|
||
}
|
||
const std::uint8_t* input_bytes = reinterpret_cast<const std::uint8_t*>(input_data.data());
|
||
const std::size_t first_chunk_size = 3 * static_cast<std::size_t>(kColumnCount) * sizeof(double) + sizeof(double);
|
||
const std::size_t second_chunk_size = sizeof(input_data) - first_chunk_size;
|
||
|
||
std::array<XYParserFrameSummary, 1> summaries{};
|
||
EXPECT_EQ(XYParser_FeedAlgorithmData(
|
||
parser.get(),
|
||
input_bytes,
|
||
first_chunk_size,
|
||
summaries.data(),
|
||
static_cast<int>(summaries.size())),
|
||
0);
|
||
|
||
ASSERT_EQ(XYParser_FeedAlgorithmData(
|
||
parser.get(),
|
||
input_bytes + first_chunk_size,
|
||
second_chunk_size,
|
||
summaries.data(),
|
||
static_cast<int>(summaries.size())),
|
||
1);
|
||
EXPECT_EQ(summaries[0].frame_index, 1U);
|
||
EXPECT_EQ(summaries[0].channel_count, 64U);
|
||
EXPECT_EQ(summaries[0].sample_count, 5U);
|
||
EXPECT_DOUBLE_EQ(summaries[0].channel_values_uv[0][0], 1000.0);
|
||
EXPECT_DOUBLE_EQ(summaries[0].channel_values_uv[2][10], 2002.0);
|
||
EXPECT_DOUBLE_EQ(summaries[0].channel_values_uv[4][63], 3004.0);
|
||
EXPECT_EQ(summaries[0].sample_trigger_types[0], 10U);
|
||
EXPECT_EQ(summaries[0].sample_trigger_indices[4], 24U);
|
||
|
||
XYParserFrameSummary tail_summary{};
|
||
ASSERT_EQ(XYParser_FlushAlgorithmData(parser.get(), &tail_summary), 1);
|
||
EXPECT_EQ(tail_summary.frame_index, 2U);
|
||
EXPECT_EQ(tail_summary.channel_count, 64U);
|
||
EXPECT_EQ(tail_summary.sample_count, 2U);
|
||
EXPECT_DOUBLE_EQ(tail_summary.channel_values_uv[0][0], 1005.0);
|
||
EXPECT_DOUBLE_EQ(tail_summary.channel_values_uv[1][63], 3006.0);
|
||
EXPECT_EQ(tail_summary.sample_trigger_types[0], 15U);
|
||
EXPECT_EQ(tail_summary.sample_trigger_indices[1], 26U);
|
||
EXPECT_DOUBLE_EQ(tail_summary.channel_values_uv[2][0], 0.0);
|
||
EXPECT_EQ(tail_summary.sample_trigger_types[2], 0U);
|
||
|
||
XYParser_ResetAlgorithmDataCache(parser.get());
|
||
EXPECT_EQ(XYParser_FlushAlgorithmData(parser.get(), &tail_summary), 0);
|
||
}
|
||
|
||
TEST(XYParserApiTests, GetLeadNameReturnsExpectedNames)
|
||
{
|
||
EXPECT_EQ(std::string(XYParser_GetLeadName(LeadChannel_FP1)), "FP1");
|
||
EXPECT_EQ(std::string(XYParser_GetLeadName(LeadChannel_PO5)), "PO5");
|
||
EXPECT_EQ(std::string(XYParser_GetLeadName(LeadChannel_OZ)), "OZ");
|
||
EXPECT_EQ(std::string(XYParser_GetLeadName(LeadChannel_GND)), "GND");
|
||
}
|
||
|
||
TEST(XYParserApiTests, GetLeadNameCovers8ChannelSubsetNames)
|
||
{
|
||
EXPECT_EQ(std::string(XYParser_GetLeadName(LeadChannel_POZ)), "POZ");
|
||
EXPECT_EQ(std::string(XYParser_GetLeadName(LeadChannel_PO6)), "PO6");
|
||
EXPECT_EQ(std::string(XYParser_GetLeadName(LeadChannel_PO7)), "PO7");
|
||
EXPECT_EQ(std::string(XYParser_GetLeadName(LeadChannel_PO8)), "PO8");
|
||
EXPECT_EQ(std::string(XYParser_GetLeadName(LeadChannel_O1)), "O1");
|
||
EXPECT_EQ(std::string(XYParser_GetLeadName(LeadChannel_O2)), "O2");
|
||
}
|
||
|
||
TEST(XYParserApiTests, GetLeadNameReturnsEmptyStringForInvalidLead)
|
||
{
|
||
EXPECT_EQ(std::string(XYParser_GetLeadName(static_cast<XYParserLeadChannelNumber>(255))), "");
|
||
}
|
||
|
||
TEST(XYParserApiTests, GetWelchBandNameReturnsExpectedNames)
|
||
{
|
||
EXPECT_EQ(std::string(XYParser_GetWelchBandName(0)), "delta");
|
||
EXPECT_EQ(std::string(XYParser_GetWelchBandName(1)), "theta");
|
||
EXPECT_EQ(std::string(XYParser_GetWelchBandName(2)), "alpha");
|
||
EXPECT_EQ(std::string(XYParser_GetWelchBandName(3)), "beta");
|
||
EXPECT_EQ(std::string(XYParser_GetWelchBandName(4)), "gamma");
|
||
}
|
||
|
||
TEST(XYParserApiTests, GetWelchBandNameReturnsEmptyStringForInvalidIndex)
|
||
{
|
||
EXPECT_EQ(std::string(XYParser_GetWelchBandName(-1)), "");
|
||
EXPECT_EQ(std::string(XYParser_GetWelchBandName(XYPARSER_WELCH_BAND_COUNT)), "");
|
||
}
|
||
|
||
TEST(XYParserApiTests, GetWelchBandRangeReturnsExpectedRanges)
|
||
{
|
||
double low_hz = 0.0;
|
||
double high_hz = 0.0;
|
||
|
||
ASSERT_EQ(XYParser_GetWelchBandRange(0, &low_hz, &high_hz), 1);
|
||
EXPECT_DOUBLE_EQ(low_hz, 0.5);
|
||
EXPECT_DOUBLE_EQ(high_hz, 4.0);
|
||
|
||
ASSERT_EQ(XYParser_GetWelchBandRange(4, &low_hz, &high_hz), 1);
|
||
EXPECT_DOUBLE_EQ(low_hz, 30.0);
|
||
EXPECT_DOUBLE_EQ(high_hz, 50.0);
|
||
}
|
||
|
||
TEST(XYParserApiTests, GetWelchBandRangeRejectsInvalidArguments)
|
||
{
|
||
double low_hz = 0.0;
|
||
double high_hz = 0.0;
|
||
|
||
EXPECT_EQ(XYParser_GetWelchBandRange(-1, &low_hz, &high_hz), 0);
|
||
EXPECT_EQ(XYParser_GetWelchBandRange(XYPARSER_WELCH_BAND_COUNT, &low_hz, &high_hz), 0);
|
||
EXPECT_EQ(XYParser_GetWelchBandRange(0, nullptr, &high_hz), 0);
|
||
EXPECT_EQ(XYParser_GetWelchBandRange(0, &low_hz, nullptr), 0);
|
||
}
|
||
|
||
TEST(XYParserApiTests, SetImpedanceDetectionSwitchesParserGainBetween24And6)
|
||
{
|
||
ParserGuard parser(XYParser_CreateParser(8));
|
||
ASSERT_NE(parser.get(), nullptr);
|
||
|
||
XYParser_SetAdcParams(parser.get(), 4.5, 6.0);
|
||
XYParser_SetBypassChecksum(parser.get(), 1);
|
||
|
||
const std::vector<std::uint8_t> frame1 = BuildMinimalFrame(8, 1U);
|
||
const std::vector<std::uint8_t> frame2 = BuildMinimalFrame(8, 2U);
|
||
const std::vector<std::uint8_t> frame3 = BuildMinimalFrame(8, 3U);
|
||
std::array<XYParserFrameSummary, 1> summaries{};
|
||
|
||
ASSERT_EQ(XYParser_Feed(parser.get(), frame1.data(), frame1.size(), summaries.data(), static_cast<int>(summaries.size())), 1);
|
||
const double gain6_value_before = summaries[0].channel_values_uv[0][0];
|
||
|
||
XYParser_SetImpedanceDetection(parser.get(), 1);
|
||
ASSERT_EQ(XYParser_Feed(parser.get(), frame2.data(), frame2.size(), summaries.data(), static_cast<int>(summaries.size())), 1);
|
||
const double gain24_value = summaries[0].channel_values_uv[0][0];
|
||
|
||
XYParser_SetImpedanceDetection(parser.get(), 0);
|
||
ASSERT_EQ(XYParser_Feed(parser.get(), frame3.data(), frame3.size(), summaries.data(), static_cast<int>(summaries.size())), 1);
|
||
const double gain6_value_after = summaries[0].channel_values_uv[0][0];
|
||
|
||
EXPECT_NEAR(gain24_value * 4.0, gain6_value_before, 1e-9);
|
||
EXPECT_NEAR(gain6_value_after, gain6_value_before, 1e-9);
|
||
}
|
||
|
||
TEST(XYParserApiTests, ImpedanceReturnsOneResultAfterOneSecondFor8Channels)
|
||
{
|
||
ParserGuard parser(XYParser_CreateParser(8));
|
||
ASSERT_NE(parser.get(), nullptr);
|
||
|
||
XYParser_SetBypassChecksum(parser.get(), 1);
|
||
XYParser_SetSampleRate(parser.get(), 10);
|
||
XYParser_SetImpedanceDetection(parser.get(), 1);
|
||
|
||
std::array<std::array<int, XYPARSER_MAX_CHANNELS>, XYPARSER_SAMPLES_PER_FRAME> raw_samples1{};
|
||
std::array<std::array<int, XYPARSER_MAX_CHANNELS>, XYPARSER_SAMPLES_PER_FRAME> raw_samples2{};
|
||
for (int sample = 0; sample < 10; ++sample) {
|
||
const int raw_value = BuildSineRawValue(sample, 10, 2.0, 1000000.0);
|
||
if (sample < static_cast<int>(XYPARSER_SAMPLES_PER_FRAME)) {
|
||
raw_samples1[static_cast<std::size_t>(sample)][0] = raw_value;
|
||
} else {
|
||
raw_samples2[static_cast<std::size_t>(sample - XYPARSER_SAMPLES_PER_FRAME)][0] = raw_value;
|
||
}
|
||
}
|
||
|
||
const std::vector<std::uint8_t> frame1 = BuildFrameWithRawSamples(8, 1U, raw_samples1);
|
||
const std::vector<std::uint8_t> frame2 = BuildFrameWithRawSamples(8, 2U, raw_samples2);
|
||
std::array<XYParserFrameSummary, 2> summaries{};
|
||
std::array<XYParserImpedanceSummary, 2> impedance{};
|
||
|
||
EXPECT_EQ(XYParser_Feed(parser.get(), frame1.data(), frame1.size(), summaries.data(), static_cast<int>(summaries.size())), 1);
|
||
EXPECT_EQ(XYParser_ReadImpedance(parser.get(), impedance.data(), static_cast<int>(impedance.size())), 0);
|
||
|
||
EXPECT_EQ(XYParser_Feed(parser.get(), frame2.data(), frame2.size(), summaries.data(), static_cast<int>(summaries.size())), 1);
|
||
ASSERT_EQ(XYParser_ReadImpedance(parser.get(), impedance.data(), static_cast<int>(impedance.size())), 1);
|
||
EXPECT_EQ(impedance[0].channel_count, 8);
|
||
EXPECT_EQ(impedance[0].sample_rate, 10U);
|
||
EXPECT_EQ(impedance[0].window_sample_count, 10U);
|
||
EXPECT_GT(impedance[0].impedance_values[LeadChannel_PO5], 0);
|
||
EXPECT_EQ(impedance[0].impedance_values[LeadChannel_FP1], 0);
|
||
}
|
||
|
||
TEST(XYParserApiTests, ImpedanceUsesUnifiedLeadIndexesFor64Channels)
|
||
{
|
||
ParserGuard parser(XYParser_CreateParser(64));
|
||
ASSERT_NE(parser.get(), nullptr);
|
||
|
||
XYParser_SetBypassChecksum(parser.get(), 1);
|
||
XYParser_SetSampleRate(parser.get(), 10);
|
||
XYParser_SetImpedanceDetection(parser.get(), 1);
|
||
|
||
std::array<std::array<int, XYPARSER_MAX_CHANNELS>, XYPARSER_SAMPLES_PER_FRAME> raw_samples1{};
|
||
std::array<std::array<int, XYPARSER_MAX_CHANNELS>, XYPARSER_SAMPLES_PER_FRAME> raw_samples2{};
|
||
for (int sample = 0; sample < 10; ++sample) {
|
||
const int raw_value = BuildSineRawValue(sample, 10, 3.0, 1000000.0);
|
||
if (sample < static_cast<int>(XYPARSER_SAMPLES_PER_FRAME)) {
|
||
raw_samples1[static_cast<std::size_t>(sample)][0] = raw_value;
|
||
} else {
|
||
raw_samples2[static_cast<std::size_t>(sample - XYPARSER_SAMPLES_PER_FRAME)][0] = raw_value;
|
||
}
|
||
}
|
||
|
||
const std::vector<std::uint8_t> frame1 = BuildFrameWithRawSamples(64, 1U, raw_samples1);
|
||
const std::vector<std::uint8_t> frame2 = BuildFrameWithRawSamples(64, 2U, raw_samples2);
|
||
std::array<XYParserFrameSummary, 2> summaries{};
|
||
std::array<XYParserImpedanceSummary, 2> impedance{};
|
||
|
||
EXPECT_EQ(XYParser_Feed(parser.get(), frame1.data(), frame1.size(), summaries.data(), static_cast<int>(summaries.size())), 1);
|
||
EXPECT_EQ(XYParser_Feed(parser.get(), frame2.data(), frame2.size(), summaries.data(), static_cast<int>(summaries.size())), 1);
|
||
ASSERT_EQ(XYParser_ReadImpedance(parser.get(), impedance.data(), static_cast<int>(impedance.size())), 1);
|
||
EXPECT_EQ(impedance[0].channel_count, 64);
|
||
EXPECT_GT(impedance[0].impedance_values[LeadChannel_FP1], 0);
|
||
EXPECT_EQ(impedance[0].impedance_values[LeadChannel_FP2], 0);
|
||
}
|
||
|
||
TEST(XYParserApiTests, WelchReturnsOneResultAfterOneSecondFromAlgorithmData)
|
||
{
|
||
ParserGuard parser(XYParser_CreateParser(64));
|
||
ASSERT_NE(parser.get(), nullptr);
|
||
|
||
XYParser_SetSampleRate(parser.get(), 10);
|
||
XYParser_SetWelchDetection(parser.get(), 1);
|
||
|
||
std::vector<double> algorithm_data(static_cast<std::size_t>(10 * XYPARSER_FRAME_DATA_COLUMN_COUNT), 0.0);
|
||
for (int sample = 0; sample < 10; ++sample) {
|
||
const std::size_t sample_offset = static_cast<std::size_t>(sample) * XYPARSER_FRAME_DATA_COLUMN_COUNT;
|
||
algorithm_data[sample_offset] = static_cast<double>(BuildSineRawValue(sample, 10, 2.0, 1000000.0));
|
||
}
|
||
|
||
std::array<XYParserWelchSummary, 2> welch{};
|
||
|
||
EXPECT_EQ(XYParser_FeedAlgorithmData(
|
||
parser.get(),
|
||
reinterpret_cast<const std::uint8_t*>(algorithm_data.data()),
|
||
algorithm_data.size() * sizeof(double),
|
||
nullptr,
|
||
0),
|
||
0);
|
||
ASSERT_EQ(XYParser_ReadWelch(parser.get(), welch.data(), static_cast<int>(welch.size())), 1);
|
||
EXPECT_EQ(welch[0].ok, 1);
|
||
EXPECT_EQ(welch[0].channel_count, 64);
|
||
EXPECT_EQ(welch[0].sample_rate, 10U);
|
||
EXPECT_EQ(welch[0].window_sample_count, 10U);
|
||
EXPECT_GT(welch[0].frequency_count, 0U);
|
||
EXPECT_DOUBLE_EQ(welch[0].frequencies[0], 1.0);
|
||
EXPECT_GT(welch[0].psd_values[LeadChannel_FP1][0], 0.0);
|
||
EXPECT_EQ(welch[0].psd_values[LeadChannel_FP2][0], 0.0);
|
||
EXPECT_GT(welch[0].band_values[0][LeadChannel_FP1], 0.0);
|
||
}
|
||
|
||
TEST(XYParserApiTests, WelchFrameFeedDoesNotProduceResults)
|
||
{
|
||
ParserGuard parser(XYParser_CreateParser(64));
|
||
ASSERT_NE(parser.get(), nullptr);
|
||
|
||
XYParser_SetBypassChecksum(parser.get(), 1);
|
||
XYParser_SetSampleRate(parser.get(), 10);
|
||
XYParser_SetWelchDetection(parser.get(), 1);
|
||
|
||
std::array<std::array<int, XYPARSER_MAX_CHANNELS>, XYPARSER_SAMPLES_PER_FRAME> raw_samples1{};
|
||
std::array<std::array<int, XYPARSER_MAX_CHANNELS>, XYPARSER_SAMPLES_PER_FRAME> raw_samples2{};
|
||
for (int sample = 0; sample < 10; ++sample) {
|
||
const int raw_value = BuildSineRawValue(sample, 10, 2.0, 1000000.0);
|
||
if (sample < static_cast<int>(XYPARSER_SAMPLES_PER_FRAME)) {
|
||
raw_samples1[static_cast<std::size_t>(sample)][0] = raw_value;
|
||
} else {
|
||
raw_samples2[static_cast<std::size_t>(sample - XYPARSER_SAMPLES_PER_FRAME)][0] = raw_value;
|
||
}
|
||
}
|
||
|
||
const std::vector<std::uint8_t> frame1 = BuildFrameWithRawSamples(64, 1U, raw_samples1);
|
||
const std::vector<std::uint8_t> frame2 = BuildFrameWithRawSamples(64, 2U, raw_samples2);
|
||
std::array<XYParserFrameSummary, 2> summaries{};
|
||
std::array<XYParserWelchSummary, 1> welch{};
|
||
|
||
EXPECT_EQ(XYParser_Feed(parser.get(), frame1.data(), frame1.size(), summaries.data(), static_cast<int>(summaries.size())), 1);
|
||
EXPECT_EQ(XYParser_Feed(parser.get(), frame2.data(), frame2.size(), summaries.data(), static_cast<int>(summaries.size())), 1);
|
||
EXPECT_EQ(XYParser_ReadWelch(parser.get(), welch.data(), static_cast<int>(welch.size())), 0);
|
||
}
|
||
|
||
TEST(XYParserApiTests, WelchDisabledDoesNotProduceResultsFromAlgorithmData)
|
||
{
|
||
ParserGuard parser(XYParser_CreateParser(64));
|
||
ASSERT_NE(parser.get(), nullptr);
|
||
|
||
XYParser_SetSampleRate(parser.get(), 10);
|
||
|
||
std::vector<double> algorithm_data(static_cast<std::size_t>(10 * XYPARSER_FRAME_DATA_COLUMN_COUNT), 0.0);
|
||
for (int sample = 0; sample < 10; ++sample) {
|
||
const std::size_t sample_offset = static_cast<std::size_t>(sample) * XYPARSER_FRAME_DATA_COLUMN_COUNT;
|
||
algorithm_data[sample_offset] = static_cast<double>(BuildSineRawValue(sample, 10, 2.0, 1000000.0));
|
||
}
|
||
|
||
std::array<XYParserWelchSummary, 1> welch{};
|
||
EXPECT_EQ(XYParser_FeedAlgorithmData(
|
||
parser.get(),
|
||
reinterpret_cast<const std::uint8_t*>(algorithm_data.data()),
|
||
algorithm_data.size() * sizeof(double),
|
||
nullptr,
|
||
0),
|
||
0);
|
||
EXPECT_EQ(XYParser_ReadWelch(parser.get(), welch.data(), static_cast<int>(welch.size())), 0);
|
||
}
|
||
|
||
/// 测试：Feed 函数能正确解析完整的 8 通道帧
|
||
TEST(XYParserApiTests, FeedParsesAComplete8ChannelFrame)
|
||
{
|
||
// 创建 8 通道解析器
|
||
ParserGuard parser(XYParser_CreateParser(8));
|
||
ASSERT_NE(parser.get(), nullptr);
|
||
|
||
// 设置 ADC 参数和校验和绕过标志
|
||
XYParser_SetAdcParams(parser.get(), 4.5, 6.0);
|
||
XYParser_SetBypassChecksum(parser.get(), 1);
|
||
|
||
// 构建测试帧并解析
|
||
const std::vector<std::uint8_t> bytes = BuildMinimalFrame(8);
|
||
std::array<XYParserFrameSummary, 1> summaries{};
|
||
|
||
const int frame_count = XYParser_Feed(
|
||
parser.get(),
|
||
bytes.data(),
|
||
bytes.size(),
|
||
summaries.data(),
|
||
static_cast<int>(summaries.size()));
|
||
|
||
// 验证解析结果
|
||
ASSERT_EQ(frame_count, 1); // 应解析出 1 帧
|
||
EXPECT_EQ(summaries[0].frame_index, 1U); // 帧索引应为 1
|
||
EXPECT_EQ(summaries[0].channel_count, 8U); // 通道数应为 8
|
||
EXPECT_EQ(summaries[0].battery, 95U); // 电池电量应为 95
|
||
EXPECT_EQ(summaries[0].sample_count, 5U); // 采样数应为 5
|
||
EXPECT_GT(summaries[0].channel_values_uv[0][0], 0.0); // 通道值应大于 0
|
||
EXPECT_EQ(summaries[0].sample_trigger_types[0], 0U); // 触发类型应为 0
|
||
EXPECT_EQ(summaries[0].sample_trigger_indices[0], 0U); // 触发索引应为 0
|
||
}
|
||
|
||
/// 测试：Feed 函数能缓冲部分数据直到完整帧可用
|
||
TEST(XYParserApiTests, FeedBuffersPartialDataUntilAFullFrameIsAvailable)
|
||
{
|
||
// 创建 8 通道解析器
|
||
ParserGuard parser(XYParser_CreateParser(8));
|
||
ASSERT_NE(parser.get(), nullptr);
|
||
|
||
// 设置校验和绕过标志
|
||
XYParser_SetBypassChecksum(parser.get(), 1);
|
||
|
||
// 构建测试帧并分成两部分
|
||
const std::vector<std::uint8_t> bytes = BuildMinimalFrame(8);
|
||
const std::size_t split_index = bytes.size() / 2;
|
||
std::array<XYParserFrameSummary, 1> summaries{};
|
||
|
||
// 第一次 Feed：传入前半部分数据
|
||
const int first_result = XYParser_Feed(
|
||
parser.get(),
|
||
bytes.data(),
|
||
split_index,
|
||
summaries.data(),
|
||
static_cast<int>(summaries.size()));
|
||
EXPECT_EQ(first_result, 0); // 数据不完整，不应解析出帧
|
||
|
||
// 第二次 Feed：传入后半部分数据
|
||
const int second_result = XYParser_Feed(
|
||
parser.get(),
|
||
bytes.data() + split_index,
|
||
bytes.size() - split_index,
|
||
summaries.data(),
|
||
static_cast<int>(summaries.size()));
|
||
ASSERT_EQ(second_result, 1); // 数据完整，应解析出 1 帧
|
||
EXPECT_EQ(summaries[0].frame_index, 1U); // 帧索引应为 1
|
||
}
|
||
|
||
// ============================================================================
|
||
// 解析器创建测试
|
||
// ============================================================================
|
||
|
||
/// 测试：成功创建 8 通道解析器
|
||
TEST(XYParserApiTests, CreateParserSucceedsFor8Channels)
|
||
{
|
||
ParserGuard parser(XYParser_CreateParser(8));
|
||
EXPECT_NE(parser.get(), nullptr);
|
||
}
|
||
|
||
/// 测试：成功创建 64 通道解析器
|
||
TEST(XYParserApiTests, CreateParserSucceedsFor64Channels)
|
||
{
|
||
ParserGuard parser(XYParser_CreateParser(64));
|
||
EXPECT_NE(parser.get(), nullptr);
|
||
}
|
||
|
||
/// 测试：创建 0 通道解析器应失败
|
||
TEST(XYParserApiTests, CreateParserRejectsZeroChannels)
|
||
{
|
||
EXPECT_EQ(XYParser_CreateParser(0), nullptr);
|
||
}
|
||
|
||
/// 测试：创建不支持的通道数（如 100）应失败
|
||
TEST(XYParserApiTests, CreateParserRejectsExcessiveChannels)
|
||
{
|
||
EXPECT_EQ(XYParser_CreateParser(100), nullptr);
|
||
}
|
||
|
||
// ============================================================================
|
||
// 参数设置函数测试
|
||
// ============================================================================
|
||
|
||
/// 测试：设置正常的 ADC 参数
|
||
TEST(XYParserApiTests, SetAdcParamsAcceptsValidValues)
|
||
{
|
||
ParserGuard parser(XYParser_CreateParser(8));
|
||
ASSERT_NE(parser.get(), nullptr);
|
||
|
||
// 不应崩溃
|
||
EXPECT_NO_THROW(XYParser_SetAdcParams(parser.get(), 4.5, 6.0));
|
||
}
|
||
|
||
/// 测试：设置边界值的 ADC 参数
|
||
TEST(XYParserApiTests, SetAdcParamsAcceptsBoundaryValues)
|
||
{
|
||
ParserGuard parser(XYParser_CreateParser(8));
|
||
ASSERT_NE(parser.get(), nullptr);
|
||
|
||
// 测试零值
|
||
EXPECT_NO_THROW(XYParser_SetAdcParams(parser.get(), 0.0, 0.0));
|
||
// 测试较大值
|
||
EXPECT_NO_THROW(XYParser_SetAdcParams(parser.get(), 100.0, 1000.0));
|
||
}
|
||
|
||
/// 测试：对空句柄调用 SetAdcParams
|
||
TEST(XYParserApiTests, SetAdcParamsOnNullHandle)
|
||
{
|
||
// 不应崩溃
|
||
EXPECT_NO_THROW(XYParser_SetAdcParams(nullptr, 4.5, 6.0));
|
||
}
|
||
|
||
/// 测试：关闭校验和绕过
|
||
TEST(XYParserApiTests, SetBypassChecksumOff)
|
||
{
|
||
ParserGuard parser(XYParser_CreateParser(8));
|
||
ASSERT_NE(parser.get(), nullptr);
|
||
|
||
EXPECT_NO_THROW(XYParser_SetBypassChecksum(parser.get(), 0));
|
||
}
|
||
|
||
/// 测试：对空句柄调用 SetBypassChecksum
|
||
TEST(XYParserApiTests, SetBypassChecksumOnNullHandle)
|
||
{
|
||
EXPECT_NO_THROW(XYParser_SetBypassChecksum(nullptr, 1));
|
||
}
|
||
|
||
// ============================================================================
|
||
// 64 导控制协议序列化测试
|
||
// ============================================================================
|
||
|
||
/// 测试：64 导开启阻抗命令序列化与 WirelessEEG 协议保持一致
|
||
TEST(XYParserApiTests, Serialize64ImpedanceOpenCommandMatchesWirelessEegProtocol)
|
||
{
|
||
std::array<std::uint8_t, 32> buffer{};
|
||
const int size = XYParser_Serialize64ImpedanceCommand(1, buffer.data(), buffer.size());
|
||
|
||
ASSERT_EQ(size, static_cast<int>(XYParser_Get64ImpedanceCommandSize()));
|
||
|
||
const std::vector<std::uint8_t> expected = {
|
||
0xAA, 0x01, 0x00, 0x07,
|
||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||
0x01, 0x09, 0x55, 0x55
|
||
};
|
||
EXPECT_TRUE(std::equal(expected.begin(), expected.end(), buffer.begin()));
|
||
}
|
||
|
||
/// 测试：64 导增益和采样率命令序列化与 WirelessEEG 协议保持一致
|
||
TEST(XYParserApiTests, Serialize64GainAndSampleRateCommandMatchesWirelessEegProtocol)
|
||
{
|
||
std::array<std::uint8_t, 32> buffer{};
|
||
const int size = XYParser_Serialize64GainSampleRateCommand(24, 1000, buffer.data(), buffer.size());
|
||
|
||
ASSERT_EQ(size, static_cast<int>(XYParser_Get64GainSampleRateCommandSize()));
|
||
|
||
const std::vector<std::uint8_t> expected = {
|
||
0xAA, 0x02, 0x00, 0x08,
|
||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||
0x18, 0x02, 0x24, 0x55, 0x55
|
||
};
|
||
EXPECT_TRUE(std::equal(expected.begin(), expected.end(), buffer.begin()));
|
||
}
|
||
|
||
/// 测试：64 导增益和采样率命令拒绝非法采样率
|
||
TEST(XYParserApiTests, Serialize64GainAndSampleRateCommandRejectsUnsupportedSampleRate)
|
||
{
|
||
std::array<std::uint8_t, 32> buffer{};
|
||
EXPECT_EQ(XYParser_Serialize64GainSampleRateCommand(24, 256, buffer.data(), buffer.size()), 0);
|
||
}
|
||
|
||
/// 测试：64 导阻抗命令在输出缓冲区不足时返回失败
|
||
TEST(XYParserApiTests, Serialize64ImpedanceCommandRejectsSmallBuffer)
|
||
{
|
||
std::array<std::uint8_t, 4> buffer{};
|
||
EXPECT_EQ(XYParser_Serialize64ImpedanceCommand(1, buffer.data(), buffer.size()), 0);
|
||
}
|
||
|
||
// ============================================================================
|
||
// Feed 函数帧解析测试
|
||
// ============================================================================
|
||
|
||
/// 测试：传入空数据
|
||
TEST(XYParserApiTests, FeedParsesEmptyData)
|
||
{
|
||
ParserGuard parser(XYParser_CreateParser(8));
|
||
ASSERT_NE(parser.get(), nullptr);
|
||
|
||
std::array<XYParserFrameSummary, 10> summaries{};
|
||
const int result = XYParser_Feed(
|
||
parser.get(),
|
||
nullptr,
|
||
0,
|
||
summaries.data(),
|
||
static_cast<int>(summaries.size()));
|
||
|
||
EXPECT_EQ(result, 0);
|
||
}
|
||
|
||
/// 测试：只传入帧头数据
|
||
TEST(XYParserApiTests, FeedParsesOnlyHeader)
|
||
{
|
||
ParserGuard parser(XYParser_CreateParser(8));
|
||
ASSERT_NE(parser.get(), nullptr);
|
||
|
||
XYParser_SetBypassChecksum(parser.get(), 1);
|
||
|
||
// 只发送帧头
|
||
const std::vector<std::uint8_t> header_only = {0xAA, 0x01, 0x00, 0x00, 0x00};
|
||
std::array<XYParserFrameSummary, 10> summaries{};
|
||
|
||
const int result = XYParser_Feed(
|
||
parser.get(),
|
||
header_only.data(),
|
||
header_only.size(),
|
||
summaries.data(),
|
||
static_cast<int>(summaries.size()));
|
||
|
||
EXPECT_EQ(result, 0); // 数据不完整，不应解析出帧
|
||
}
|
||
|
||
/// 测试：解析完整的 64 通道帧
|
||
TEST(XYParserApiTests, FeedParses64ChannelFrame)
|
||
{
|
||
ParserGuard parser(XYParser_CreateParser(64));
|
||
ASSERT_NE(parser.get(), nullptr);
|
||
|
||
XYParser_SetAdcParams(parser.get(), 4.5, 6.0);
|
||
XYParser_SetBypassChecksum(parser.get(), 1);
|
||
|
||
const std::vector<std::uint8_t> bytes = BuildMinimalFrame(64);
|
||
std::array<XYParserFrameSummary, 1> summaries{};
|
||
|
||
const int frame_count = XYParser_Feed(
|
||
parser.get(),
|
||
bytes.data(),
|
||
bytes.size(),
|
||
summaries.data(),
|
||
static_cast<int>(summaries.size()));
|
||
|
||
ASSERT_EQ(frame_count, 1);
|
||
EXPECT_EQ(summaries[0].channel_count, 64U);
|
||
}
|
||
|
||
/// 测试：连续解析多个帧
|
||
TEST(XYParserApiTests, FeedParsesMultipleFrames)
|
||
{
|
||
ParserGuard parser(XYParser_CreateParser(8));
|
||
ASSERT_NE(parser.get(), nullptr);
|
||
|
||
XYParser_SetBypassChecksum(parser.get(), 1);
|
||
|
||
// 构建两个连续的帧
|
||
const std::vector<std::uint8_t> frame1 = BuildMinimalFrame(8, 1U);
|
||
const std::vector<std::uint8_t> frame2 = BuildMinimalFrame(8, 2U);
|
||
|
||
std::vector<std::uint8_t> combined(frame1);
|
||
combined.insert(combined.end(), frame2.begin(), frame2.end());
|
||
|
||
std::array<XYParserFrameSummary, 10> summaries{};
|
||
const int frame_count = XYParser_Feed(
|
||
parser.get(),
|
||
combined.data(),
|
||
combined.size(),
|
||
summaries.data(),
|
||
static_cast<int>(summaries.size()));
|
||
|
||
EXPECT_EQ(frame_count, 2);
|
||
EXPECT_EQ(summaries[0].frame_index, 1U);
|
||
EXPECT_EQ(summaries[1].frame_index, 2U);
|
||
}
|
||
|
||
/// 测试：帧索引递增
|
||
TEST(XYParserApiTests, FeedIncrementsFrameIndex)
|
||
{
|
||
ParserGuard parser(XYParser_CreateParser(8));
|
||
ASSERT_NE(parser.get(), nullptr);
|
||
|
||
XYParser_SetBypassChecksum(parser.get(), 1);
|
||
|
||
// 连续发送多个帧
|
||
std::array<XYParserFrameSummary, 10> summaries{};
|
||
int total_frames = 0;
|
||
|
||
for (int i = 0; i < 3; ++i) {
|
||
const std::vector<std::uint8_t> frame = BuildMinimalFrame(8, static_cast<std::uint32_t>(i + 1));
|
||
const int count = XYParser_Feed(
|
||
parser.get(),
|
||
frame.data(),
|
||
frame.size(),
|
||
summaries.data() + total_frames,
|
||
static_cast<int>(summaries.size()) - total_frames);
|
||
total_frames += count;
|
||
}
|
||
|
||
EXPECT_EQ(total_frames, 3);
|
||
for (int i = 0; i < 3; ++i) {
|
||
EXPECT_EQ(summaries[i].frame_index, static_cast<std::uint32_t>(i + 1));
|
||
}
|
||
}
|
||
|
||
/// 测试：电池电量字段解析
|
||
TEST(XYParserApiTests, FeedParsesBatteryValue)
|
||
{
|
||
ParserGuard parser(XYParser_CreateParser(8));
|
||
ASSERT_NE(parser.get(), nullptr);
|
||
|
||
XYParser_SetBypassChecksum(parser.get(), 1);
|
||
|
||
const std::vector<std::uint8_t> bytes = BuildMinimalFrame(8);
|
||
std::array<XYParserFrameSummary, 1> summaries{};
|
||
|
||
XYParser_Feed(
|
||
parser.get(),
|
||
bytes.data(),
|
||
bytes.size(),
|
||
summaries.data(),
|
||
static_cast<int>(summaries.size()));
|
||
|
||
EXPECT_EQ(summaries[0].battery, 95U); // BuildMinimalFrame 中设置的电池电量
|
||
}
|
||
|
||
// ============================================================================
|
||
// 帧数据边界测试
|
||
// ============================================================================
|
||
|
||
/// 测试：跨多次 Feed 的不完整帧
|
||
TEST(XYParserApiTests, FeedHandlesIncompleteFrameAcrossMultipleFeeds)
|
||
{
|
||
ParserGuard parser(XYParser_CreateParser(8));
|
||
ASSERT_NE(parser.get(), nullptr);
|
||
|
||
XYParser_SetBypassChecksum(parser.get(), 1);
|
||
|
||
const std::vector<std::uint8_t> bytes = BuildMinimalFrame(8);
|
||
std::array<XYParserFrameSummary, 1> summaries{};
|
||
|
||
// 分成 3 次发送
|
||
const std::size_t part1_size = bytes.size() / 3;
|
||
const std::size_t part2_size = bytes.size() / 3;
|
||
|
||
EXPECT_EQ(XYParser_Feed(parser.get(), bytes.data(), part1_size,
|
||
summaries.data(), static_cast<int>(summaries.size())), 0);
|
||
|
||
EXPECT_EQ(XYParser_Feed(parser.get(), bytes.data() + part1_size, part2_size,
|
||
summaries.data(), static_cast<int>(summaries.size())), 0);
|
||
|
||
const int result = XYParser_Feed(
|
||
parser.get(),
|
||
bytes.data() + part1_size + part2_size,
|
||
bytes.size() - part1_size - part2_size,
|
||
summaries.data(),
|
||
static_cast<int>(summaries.size()));
|
||
|
||
ASSERT_EQ(result, 1);
|
||
EXPECT_EQ(summaries[0].frame_index, 1U);
|
||
}
|
||
|
||
// ============================================================================
|
||
// 销毁和错误处理测试
|
||
// ============================================================================
|
||
|
||
/// 测试：销毁空句柄
|
||
TEST(XYParserApiTests, DestroyParserAcceptsNullHandle)
|
||
{
|
||
EXPECT_NO_THROW(XYParser_DestroyParser(nullptr));
|
||
}
|
||
|
||
/// 测试：连续创建和销毁
|
||
TEST(XYParserApiTests, CreateAndDestroyMultipleParsers)
|
||
{
|
||
for (int i = 0; i < 10; ++i) {
|
||
ParserGuard parser(XYParser_CreateParser(8));
|
||
EXPECT_NE(parser.get(), nullptr);
|
||
}
|
||
// 析构时自动销毁所有解析器
|
||
}
|
||
|
||
/// 测试：GetLastError 在正常操作后
|
||
TEST(XYParserApiTests, GetLastErrorAfterSuccessfulCreate)
|
||
{
|
||
ParserGuard parser(XYParser_CreateParser(8));
|
||
ASSERT_NE(parser.get(), nullptr);
|
||
|
||
// 正常操作后，错误信息应为空（空字符串）,不能是 nullptr
|
||
const char* error = XYParser_GetLastError(parser.get());
|
||
EXPECT_TRUE(std::string(error).empty());
|
||
}
|
||
|
||
|