Files
STM32F4-Base/IEC60870-Slave/test/iec104_response_queue_test.c
T
STF bdcc8b6500
CI / L0 静态门禁 (pre-commit) (push) Failing after 7m46s
CI / L0.5 主机侧单测 (MSVC) (push) Successful in 21s
添加遥控、参数装载、文件传输等业务
2026-11-16 22:19:17 -08:00

751 lines
40 KiB
C
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
/* Response HIGH storage tests: independent byte layout and lifecycle checks. */
/*
* 文件内导航(搜索方括号标记;Suite:Transport):
* 通用HIGH/NORMAL队列单测;Fixture仅在本文件共用,验证各队列FIFO,不建立跨队列屏障。
* [COMMON/BASE] 公共基础:依赖、编译选项与断言入口
* [COMMON/FIXTURE] 公共夹具:固定队列存储、测试载荷及入队/取队首辅助
* [QUEUE/LAYOUT] 队列布局用例:FIFO、双队列独立与跨环尾字节
* [QUEUE/LIFETIME] 队列生命周期用例:NORMAL覆盖、精确取消、EOF与编号
* [QUEUE/ERRORS] 队列失败用例:覆盖原子性、容量耗尽及输出不变
* [QUEUE/FILTER] 系统命令清除用例:按CA/类型筛选、稳定环压缩、离线与失败原子性
* [ENTRY/MAIN] 测试入口:队列布局、生命周期与失败路径
* 公共辅助、业务专属辅助和用例按分区阅读;RUN/CASE标记用于细分执行组。
*/
/* ============================================================================
* [COMMON/BASE] 公共基础:依赖、编译选项与断言入口
* ============================================================================ */
#include "IEC104_AsduQueue.h"
#include <stdio.h>
#include <string.h>
#define CHECK(condition) do { if (!(condition)) { \
fprintf(stderr, "%s:%d: %s\n", __func__, __LINE__, #condition); return 0; } } while (0)
/* ============================================================================
* [COMMON/FIXTURE] 公共夹具:固定队列存储、测试载荷及入队/取队首辅助
* ============================================================================ */
typedef struct {
IEC104_AsduQueue_t queue;
uint8_t high[1024], normal[1024];
} Fixture;
static const uint8_t value[] = {1U, 1U, 3U, 0U, 1U, 0U};
/**
* 功能:每次从非零哨兵开始,generation固定为1。
* 输入参数:f——测试夹具;high——HIGH 队列容量(字节);normal——NORMAL 队列容量(字节);sequence——初始票据序号或 I 帧发送序号。
* 输出参数:f——操作后的测试夹具和队列状态。
* 返回值:非零表示本次操作或检查通过;0 表示失败。
* 说明:sequence用于单独控制HIGH凭证的起始编号。
*/
static int init(Fixture *f, uint32_t high, uint32_t normal, uint64_t sequence)
{
memset(f, 0xa5, sizeof(*f));
return IEC104_AsduQueue_Init(&f->queue, f->high, high, f->normal, normal, 1U, sequence) == IEC104_ASDU_QUEUE_OK;
}
/**
* 功能:加入一条普通NORMAL原文。
* 输入参数:f——测试夹具。
* 输出参数:f——操作后的测试夹具和队列状态。
* 返回值:非零表示本次操作或检查通过;0 表示失败。
* 说明:调用方随后控制提交、覆盖和ACK,辅助本身不模拟发送。
*/
static int normal(Fixture *f)
{
return IEC104_AsduQueue_Enqueue(&f->queue, 1U, IEC104_ASDU_PRIORITY_NORMAL,
value, sizeof(value)) == IEC104_ASDU_QUEUE_OK;
}
/**
* 功能:加入无凭证的HIGH原文,用于验证它与带凭证应答共用同一FIFO。
* 输入参数:f——测试夹具。
* 输出参数:f——操作后的测试夹具和队列状态。
* 返回值:非零表示本次操作或检查通过;0 表示失败。
* 说明:本辅助入口用于构造或核对上述测试场景,相关状态保存在当前测试夹具中。
*/
static int high(Fixture *f)
{
return IEC104_AsduQueue_Enqueue(&f->queue, 1U, IEC104_ASDU_PRIORITY_HIGH,
value, sizeof(value)) == IEC104_ASDU_QUEUE_OK;
}
/**
* 功能:加入可查询交接状态的HIGH原文。
* 输入参数:f——测试夹具;ticket——发送跟踪票据。
* 输出参数:f——操作后的测试夹具和队列状态;ticket——提交成功时返回的跟踪票据。
* 返回值:非零表示本次操作或检查通过;0 表示失败。
* 说明:票据输出只由成功的队列入口写入。
*/
static int tracked(Fixture *f, uint64_t *ticket)
{
return IEC104_AsduQueue_Enqueue_Response(&f->queue, 1U, value, sizeof(value), ticket) == IEC104_ASDU_QUEUE_OK;
}
/**
* 功能:仅模拟队列交接/丢弃,不执行socket发送。
* 输入参数:f——测试夹具;priority——存储或业务优先级;discard——是否丢弃队首而非交接。
* 输出参数:f——操作后的测试夹具和队列状态。
* 返回值:非零表示本次操作或检查通过;0 表示失败。
* 说明:discard=0的HANDED不代表写完或被主站ACK。
*/
static int remove_head(Fixture *f, IEC104_AsduPriority_t priority, int discard)
{
IEC104_AsduHeadInfo_t info;
if (IEC104_AsduQueue_Peek_Unsubmitted(&f->queue, priority, &info) != IEC104_ASDU_QUEUE_OK) { return 0; }
return (discard ? IEC104_AsduQueue_Discard_Unsubmitted_Head(&f->queue, priority, info.entry_id) :
IEC104_AsduQueue_Mark_Submitted(&f->queue, priority, info.entry_id)) == IEC104_ASDU_QUEUE_OK;
}
/* ============================================================================
* [QUEUE/LAYOUT] 队列布局用例:FIFO、双队列独立与跨环尾字节
* ============================================================================ */
/**
* 功能:验证普通 HIGH 与带票据响应共用 FIFO 和序号,交接后票据由 PENDING 变为 HANDED,NORMAL 保持独立。
* 输入参数:无。
* 输出参数:无。
* 返回值:非零表示本次操作或检查通过;0 表示失败。
* 说明:检查不满足时由 CHECK 立即返回失败,不继续后续断言。
*/
static int mixed_fifo(void)
{
Fixture f;
IEC104_AsduHeadInfo_t info;
uint64_t ticket = 0U;
CHECK(init(&f, sizeof(f.high), sizeof(f.normal), 10U));
CHECK(normal(&f) && high(&f) && tracked(&f, &ticket) && high(&f));
/* 普通HIGH也占用序号,Tracked只把其中一个序号返回给调用方;两种入口共用FIFO。 */
CHECK(ticket == 11U && f.queue.high_next_sequence == 13U);
CHECK(IEC104_AsduQueue_Get_Entry_By_Offset(&f.queue, IEC104_ASDU_PRIORITY_HIGH, 1U, &info) == IEC104_ASDU_QUEUE_OK);
CHECK(info.entry_header_length == 2U);
CHECK(f.queue.priority_queues[IEC104_ASDU_PRIORITY_HIGH].used_bytes == 24U);
CHECK(IEC104_AsduQueue_Get_Response_State(&f.queue, ticket) == IEC104_RESPONSE_PENDING);
CHECK(remove_head(&f, IEC104_ASDU_PRIORITY_HIGH, 0));
CHECK(f.queue.high_head_sequence == 11U);
CHECK(remove_head(&f, IEC104_ASDU_PRIORITY_HIGH, 0));
CHECK(IEC104_AsduQueue_Get_Response_State(&f.queue, ticket) == IEC104_RESPONSE_HANDED);
CHECK(f.queue.priority_queues[IEC104_ASDU_PRIORITY_NORMAL].unsubmitted_count == 1U);
CHECK(remove_head(&f, IEC104_ASDU_PRIORITY_HIGH, 0));
CHECK(f.queue.high_head_sequence == f.queue.high_next_sequence);
return 1;
}
/**
* 功能:交替加入HIGH/NORMAL后仅推进HIGH,核对凭证交接顺序及NORMAL待发数量不变。
* 输入参数:无。
* 输出参数:无。
* 返回值:非零表示本次操作或检查通过;0 表示失败。
* 说明:检查不满足时由 CHECK 立即返回失败,不继续后续断言。
*/
static int independent_queues(void)
{
Fixture f;
uint64_t first, second;
CHECK(init(&f, sizeof(f.high), sizeof(f.normal), 1U));
CHECK(normal(&f) && tracked(&f, &first) && normal(&f) && tracked(&f, &second));
CHECK(remove_head(&f, IEC104_ASDU_PRIORITY_HIGH, 0));
CHECK(IEC104_AsduQueue_Get_Response_State(&f.queue, first) == IEC104_RESPONSE_HANDED);
CHECK(IEC104_AsduQueue_Get_Response_State(&f.queue, second) == IEC104_RESPONSE_PENDING);
CHECK(remove_head(&f, IEC104_ASDU_PRIORITY_HIGH, 0));
CHECK(f.queue.priority_queues[IEC104_ASDU_PRIORITY_NORMAL].unsubmitted_count == 2U);
return 1;
}
/**
* 功能:两次入队把尾部推进到78:容量79使两字节头跨尾,容量83使载荷跨尾,均须完整取回。
* 输入参数:无。
* 输出参数:无。
* 返回值:非零表示本次操作或检查通过;0 表示失败。
* 说明:检查不满足时由 CHECK 立即返回失败,不继续后续断言。
*/
static int wrapped_headers(void)
{
unsigned capacity;
for (capacity = 79U; capacity <= 83U; capacity += 4U) {
Fixture f;
IEC104_AsduHeadInfo_t info;
uint8_t first[62], second[12], copy[6], header[2];
uint16_t encoded;
uint64_t ticket;
unsigned index;
memset(first, 0x11, sizeof(first)); memset(second, 0x22, sizeof(second));
CHECK(init(&f, capacity, sizeof(f.normal), 1U));
f.queue.next_entry_serial = UINT64_C(0x0102030405060708);
CHECK(IEC104_AsduQueue_Enqueue(&f.queue, 1U, IEC104_ASDU_PRIORITY_HIGH, first, sizeof(first)) == IEC104_ASDU_QUEUE_OK);
CHECK(IEC104_AsduQueue_Enqueue(&f.queue, 1U, IEC104_ASDU_PRIORITY_HIGH, second, sizeof(second)) == IEC104_ASDU_QUEUE_OK);
CHECK(remove_head(&f, IEC104_ASDU_PRIORITY_HIGH, 0));
CHECK(tracked(&f, &ticket));
for (index = 0U; index < sizeof(header); ++index) { header[index] = f.high[(78U + index) % capacity]; }
memcpy(&encoded, header, 2U);
CHECK(encoded == 6U);
CHECK(f.queue.priority_queues[IEC104_ASDU_PRIORITY_HIGH].used_bytes == 22U);
CHECK(IEC104_AsduQueue_Get_Entry_By_Offset(&f.queue, IEC104_ASDU_PRIORITY_HIGH, 1U, &info) == IEC104_ASDU_QUEUE_OK);
CHECK(info.entry_header_length == 2U);
CHECK(IEC104_AsduQueue_Copy_Asdu(&info, copy, sizeof(copy)) == IEC104_ASDU_QUEUE_OK);
CHECK(memcmp(copy, value, sizeof(value)) == 0);
CHECK(remove_head(&f, IEC104_ASDU_PRIORITY_HIGH, 0) && remove_head(&f, IEC104_ASDU_PRIORITY_HIGH, 0));
CHECK(IEC104_AsduQueue_Get_Response_State(&f.queue, ticket) == IEC104_RESPONSE_HANDED);
}
return 1;
}
/* ============================================================================
* [QUEUE/LIFETIME] 队列生命周期用例:NORMAL覆盖、精确取消、EOF与编号
* ============================================================================ */
/**
* 功能:NORMAL只留一个条目的空间并反复覆盖。
* 输入参数:无。
* 输出参数:无。
* 返回值:非零表示本次操作或检查通过;0 表示失败。
* 说明:HIGH凭证不依赖NORMAL出队进度。
*/
static int overwrite_and_discard_normal(void)
{
Fixture f;
uint64_t ticket;
CHECK(init(&f, sizeof(f.high), IEC104_ASDU_NORMAL_ENTRY_HEADER_LEN + sizeof(value), 1U));
CHECK(normal(&f) && tracked(&f, &ticket) && normal(&f) && normal(&f));
CHECK(f.queue.priority_queues[IEC104_ASDU_PRIORITY_NORMAL].unsubmitted_count == 1U);
CHECK(IEC104_AsduQueue_Get_Response_State(&f.queue, ticket) == IEC104_RESPONSE_PENDING);
CHECK(remove_head(&f, IEC104_ASDU_PRIORITY_NORMAL, 1));
CHECK(IEC104_AsduQueue_Get_Response_State(&f.queue, ticket) == IEC104_RESPONSE_PENDING);
CHECK(remove_head(&f, IEC104_ASDU_PRIORITY_HIGH, 0));
CHECK(IEC104_AsduQueue_Get_Response_State(&f.queue, ticket) == IEC104_RESPONSE_HANDED);
return 1;
}
/**
* 功能:交替交接、丢弃和Reset,核对当前可判定区间内的票据结果。
* 输入参数:无。
* 输出参数:无。
* 返回值:非零表示本次操作或检查通过;0 表示失败。
* 说明:后续Reset收缩历史边界后,更早票据按保守取消处理,不能假定所有交接历史永久保留。
*/
static int precise_cancellation(void)
{
Fixture f;
uint64_t a, b, c;
CHECK(init(&f, sizeof(f.high), sizeof(f.normal), 10U));
CHECK(high(&f) && tracked(&f, &a) && tracked(&f, &b));
CHECK(remove_head(&f, IEC104_ASDU_PRIORITY_HIGH, 1));
CHECK(f.queue.high_cancel_begin == 10U && f.queue.high_cancel_end == 11U);
CHECK(IEC104_AsduQueue_Get_Response_State(&f.queue, 10U) == IEC104_RESPONSE_CANCELLED);
CHECK(IEC104_AsduQueue_Get_Response_State(&f.queue, a) == IEC104_RESPONSE_PENDING);
CHECK(IEC104_AsduQueue_Get_Response_State(&f.queue, b) == IEC104_RESPONSE_PENDING);
CHECK(remove_head(&f, IEC104_ASDU_PRIORITY_HIGH, 0));
CHECK(remove_head(&f, IEC104_ASDU_PRIORITY_HIGH, 1));
CHECK(f.queue.high_known_from == 11U && f.queue.high_cancel_begin == b && f.queue.high_cancel_end == b + 1U);
CHECK(IEC104_AsduQueue_Get_Response_State(&f.queue, a) == IEC104_RESPONSE_HANDED);
CHECK(IEC104_AsduQueue_Get_Response_State(&f.queue, b) == IEC104_RESPONSE_CANCELLED);
CHECK(IEC104_AsduQueue_Reset_High(&f.queue, 1U) == IEC104_ASDU_QUEUE_OK);
CHECK(f.queue.high_cancel_begin == b && f.queue.high_known_from == 11U);
CHECK(tracked(&f, &c) && high(&f));
CHECK(IEC104_AsduQueue_Reset_High(&f.queue, 1U) == IEC104_ASDU_QUEUE_OK);
CHECK(f.queue.high_cancel_begin == c && f.queue.high_cancel_end == c + 2U);
CHECK(IEC104_AsduQueue_Get_Response_State(&f.queue, a) == IEC104_RESPONSE_CANCELLED);
CHECK(IEC104_AsduQueue_Get_Response_State(&f.queue, c) == IEC104_RESPONSE_CANCELLED);
return 1;
}
/**
* 功能:NORMAL发送限制、Detach、Rebind及Abort共享同一生命周期。
* 输入参数:无。
* 输出参数:无。
* 返回值:非零表示本次操作或检查通过;0 表示失败。
* 说明:旧HIGH取消结果在重建后仍可识别。
*/
static int lifecycle_and_eof(void)
{
Fixture f;
IEC104_AsduHeadInfo_t info;
uint64_t ticket, next;
CHECK(init(&f, sizeof(f.high), sizeof(f.normal), 1U));
CHECK(normal(&f) && tracked(&f, &ticket));
CHECK(IEC104_AsduQueue_Limit_Normal_Send(&f.queue, 1U) == IEC104_ASDU_QUEUE_OK);
CHECK(IEC104_AsduQueue_Peek_Unsubmitted(&f.queue, IEC104_ASDU_PRIORITY_NORMAL, &info) == IEC104_ASDU_QUEUE_EMPTY);
CHECK(IEC104_AsduQueue_Detach(&f.queue, 1U) == IEC104_ASDU_QUEUE_OK);
CHECK(IEC104_AsduQueue_Get_Response_State(&f.queue, ticket) == IEC104_RESPONSE_CANCELLED);
CHECK(IEC104_AsduQueue_Rebind(&f.queue, 2U) == IEC104_ASDU_QUEUE_OK);
CHECK(f.queue.high_cancel_begin == ticket);
CHECK(IEC104_AsduQueue_Get_Response_State(&f.queue, ticket) == IEC104_RESPONSE_CANCELLED);
next = f.queue.high_next_sequence;
IEC104_AsduQueue_Abort(&f.queue);
CHECK(IEC104_AsduQueue_Get_Response_State(&f.queue, ticket) == IEC104_RESPONSE_CANCELLED);
CHECK(IEC104_AsduQueue_Get_Response_State(&f.queue, 0U) == IEC104_RESPONSE_HANDED);
CHECK(init(&f, sizeof(f.high), sizeof(f.normal), next));
CHECK(IEC104_AsduQueue_Get_Response_State(&f.queue, ticket) == IEC104_RESPONSE_CANCELLED);
CHECK(IEC104_AsduQueue_Get_Response_State(&f.queue, next) == IEC104_RESPONSE_ERROR);
return 1;
}
/**
* 功能:启动暂停仅门控出队:仍允许入队、覆盖和已提交条目的ACK清理,HIGH不受影响。
* 输入参数:无。
* 输出参数:无。
* 返回值:非零表示本次操作或检查通过;0 表示失败。
* 说明:Detach/Rebind保留启动暂停;解除启动暂停不能误清独立EOF限制。
*/
static int startup_gate_and_eof(void)
{
Fixture f, before;
IEC104_AsduHeadInfo_t original, head;
IEC104_AsduQueueStatus_t status;
CHECK(init(&f, sizeof(f.high), 2U * (IEC104_ASDU_NORMAL_ENTRY_HEADER_LEN + sizeof(value)), 1U));
CHECK(normal(&f));
CHECK(IEC104_AsduQueue_Peek_Unsubmitted(&f.queue, IEC104_ASDU_PRIORITY_NORMAL, &original) == IEC104_ASDU_QUEUE_OK);
CHECK(IEC104_AsduQueue_Mark_Submitted(&f.queue, IEC104_ASDU_PRIORITY_NORMAL, original.entry_id) == IEC104_ASDU_QUEUE_OK);
CHECK(normal(&f));
CHECK(IEC104_AsduQueue_Set_Startup_Pending(&f.queue, 1U, 1U) == IEC104_ASDU_QUEUE_OK);
CHECK(IEC104_AsduQueue_Peek_Unsubmitted(&f.queue, IEC104_ASDU_PRIORITY_NORMAL, &head) == IEC104_ASDU_QUEUE_EMPTY);
CHECK(high(&f));
CHECK(IEC104_AsduQueue_Peek_Unsubmitted(&f.queue, IEC104_ASDU_PRIORITY_HIGH, &head) == IEC104_ASDU_QUEUE_OK);
CHECK(IEC104_AsduQueue_Confirm_Next_Normal_Entry(&f.queue,
IEC104_ASDU_PRIORITY_NORMAL, original.entry_id) == IEC104_ASDU_QUEUE_OK);
CHECK(normal(&f) && normal(&f));
CHECK(IEC104_AsduQueue_Get_Status(&f.queue, &status) == IEC104_ASDU_QUEUE_OK);
CHECK(status.entry_count[IEC104_ASDU_PRIORITY_NORMAL] == 2U &&
status.retained_unacked_count[IEC104_ASDU_PRIORITY_NORMAL] == 0U);
before = f;
CHECK(IEC104_AsduQueue_Set_Startup_Pending(&f.queue, 2U, 0U) == IEC104_ASDU_QUEUE_ERROR);
CHECK(IEC104_AsduQueue_Set_Startup_Pending(&f.queue, 1U, 2U) == IEC104_ASDU_QUEUE_ERROR);
CHECK(memcmp(&f, &before, sizeof(f)) == 0);
CHECK(IEC104_AsduQueue_Detach(&f.queue, 1U) == IEC104_ASDU_QUEUE_OK);
CHECK(IEC104_AsduQueue_Rebind(&f.queue, 2U) == IEC104_ASDU_QUEUE_OK);
CHECK(IEC104_AsduQueue_Peek_Unsubmitted(&f.queue, IEC104_ASDU_PRIORITY_NORMAL, &head) == IEC104_ASDU_QUEUE_EMPTY);
CHECK(IEC104_AsduQueue_Set_Startup_Pending(&f.queue, 2U, 0U) == IEC104_ASDU_QUEUE_OK);
CHECK(IEC104_AsduQueue_Peek_Unsubmitted(&f.queue, IEC104_ASDU_PRIORITY_NORMAL, &head) == IEC104_ASDU_QUEUE_OK);
CHECK(IEC104_AsduQueue_Limit_Normal_Send(&f.queue, 2U) == IEC104_ASDU_QUEUE_OK);
CHECK(IEC104_AsduQueue_Set_Startup_Pending(&f.queue, 2U, 1U) == IEC104_ASDU_QUEUE_OK);
CHECK(IEC104_AsduQueue_Set_Startup_Pending(&f.queue, 2U, 0U) == IEC104_ASDU_QUEUE_OK);
CHECK(IEC104_AsduQueue_Peek_Unsubmitted(&f.queue, IEC104_ASDU_PRIORITY_NORMAL, &head) == IEC104_ASDU_QUEUE_EMPTY);
return 1;
}
/**
* 功能:NORMAL条目号回绕或跨半环距离,不应污染独立的HIGH应答序号和PENDING状态。
* 输入参数:无。
* 输出参数:无。
* 返回值:非零表示本次操作或检查通过;0 表示失败。
* 说明:检查不满足时由 CHECK 立即返回失败,不继续后续断言。
*/
static int normal_serials_independent_of_responses(void)
{
Fixture f;
uint64_t ticket;
CHECK(init(&f, sizeof(f.high), sizeof(f.normal), 1U));
f.queue.next_entry_serial = UINT64_MAX - 1U;
CHECK(normal(&f) && tracked(&f, &ticket) && normal(&f) && normal(&f));
CHECK(f.queue.next_entry_serial == 2U);
CHECK(remove_head(&f, IEC104_ASDU_PRIORITY_HIGH, 0));
CHECK(init(&f, sizeof(f.high), sizeof(f.normal), 1U));
CHECK(tracked(&f, &ticket));
f.queue.next_entry_serial = UINT64_MAX / 2U + 1U;
CHECK(normal(&f));
CHECK(IEC104_AsduQueue_Get_Response_State(&f.queue, ticket) == IEC104_RESPONSE_PENDING);
return 1;
}
/* ============================================================================
* [QUEUE/ERRORS] 队列失败用例:覆盖原子性、容量耗尽及输出不变
* ============================================================================ */
/**
* 功能:在 NORMAL 已覆盖未确认条目的条件下耗尽序号,验证新入队失败且整个夹具逐字节不变。
* 输入参数:无。
* 输出参数:无。
* 返回值:非零表示本次操作或检查通过;0 表示失败。
* 说明:检查不满足时由 CHECK 立即返回失败,不继续后续断言。
*/
static int overwrite_failure_is_atomic(void)
{
Fixture f, before;
uint64_t ticket;
CHECK(init(&f, sizeof(f.high), IEC104_ASDU_NORMAL_ENTRY_HEADER_LEN + sizeof(value), 1U));
CHECK(normal(&f) && remove_head(&f, IEC104_ASDU_PRIORITY_NORMAL, 0) && normal(&f));
CHECK(f.queue.overwritten_unacked_count == 1U && tracked(&f, &ticket));
f.queue.next_entry_serial = UINT64_MAX / 2U + 1U;
before = f;
CHECK(IEC104_AsduQueue_Enqueue(&f.queue, 1U, IEC104_ASDU_PRIORITY_NORMAL, value, sizeof(value)) == IEC104_ASDU_QUEUE_FULL);
CHECK(memcmp(&f, &before, sizeof(f)) == 0);
return 1;
}
/**
* 功能:249字节ASDU加2字节HIGH头恰占251:不可容纳返回ERROR,已占满返回FULL。
* 输入参数:无。
* 输出参数:无。
* 返回值:非零表示本次操作或检查通过;0 表示失败。
* 说明:均保留输出凭证。
*/
static int capacity_exhaustion_and_output(void)
{
Fixture f, before;
uint64_t ticket = 777U;
uint8_t maximum[249];
memset(maximum, 0x5a, sizeof(maximum));
CHECK(init(&f, 250U, sizeof(f.normal), 1U));
before = f;
CHECK(IEC104_AsduQueue_Enqueue_Response(&f.queue, 1U, maximum, sizeof(maximum), &ticket) == IEC104_ASDU_QUEUE_ERROR);
CHECK(ticket == 777U && memcmp(&f, &before, sizeof(f)) == 0);
CHECK(init(&f, 251U, sizeof(f.normal), 1U));
CHECK(IEC104_AsduQueue_Enqueue_Response(&f.queue, 1U, maximum, sizeof(maximum), &ticket) == IEC104_ASDU_QUEUE_OK);
CHECK(ticket == 1U && f.queue.priority_queues[IEC104_ASDU_PRIORITY_HIGH].used_bytes == 251U);
before = f; ticket = 777U;
CHECK(IEC104_AsduQueue_Enqueue_Response(&f.queue, 1U, value, sizeof(value), &ticket) == IEC104_ASDU_QUEUE_FULL);
CHECK(ticket == 777U && memcmp(&f, &before, sizeof(f)) == 0);
CHECK(init(&f, sizeof(f.high), sizeof(f.normal), UINT64_MAX - 1U));
CHECK(tracked(&f, &ticket) && ticket == UINT64_MAX - 1U);
before = f; ticket = 777U;
CHECK(IEC104_AsduQueue_Enqueue_Response(&f.queue, 1U, value, sizeof(value), &ticket) == IEC104_ASDU_QUEUE_ERROR);
CHECK(ticket == 777U && memcmp(&f, &before, sizeof(f)) == 0);
CHECK(!high(&f) && memcmp(&f, &before, sizeof(f)) == 0);
CHECK(normal(&f));
return 1;
}
/* ============================================================================
* [QUEUE/FILTER] 系统命令清除用例:按CA/类型筛选、稳定环压缩、离线与失败原子性
* ============================================================================ */
/**
* 功能:独立生成指定 Type、CA、长度及样本字节的队列筛选测试原文。
* 输入参数:bytes——报文字节缓冲区;length——字节长度;type——协议类型或期望事件类型;ca——公共地址;seed——正文样本的起始字节。
* 输出参数:bytes——写入或读出的数据字节。
* 返回值:无。
* 说明:期望原文由测试独立构造;仅固定Type与CA,其他字节刻意不采用合法业务对象,
* 确认通用队列不把结构筛选扩展成ASDU业务校验。
*/
static void filter_payload(uint8_t *bytes, uint16_t length, uint8_t type, uint16_t ca, uint8_t seed)
{
uint16_t i;
for (i = 0U; i < length; ++i) { bytes[i] = (uint8_t)(seed + i); }
bytes[0] = type;
bytes[4] = (uint8_t)ca;
bytes[5] = (uint8_t)(ca >> 8);
}
/**
* 功能:生成指定Type/CA和长度的可区分原文,加入NORMAL供清除过滤用例检查。
* 输入参数:f——测试夹具;type——协议类型或期望事件类型;ca——公共地址;seed——正文样本的起始字节;length——字节长度。
* 输出参数:f——操作后的测试夹具和队列状态。
* 返回值:非零表示本次操作或检查通过;0 表示失败。
* 说明:本辅助入口用于构造或核对上述测试场景,相关状态保存在当前测试夹具中。
*/
static int enqueue_filter_value(Fixture *f, uint8_t type, uint16_t ca, uint8_t seed, uint16_t length)
{
uint8_t bytes[IEC104_MAX_ASDU_LEN];
filter_payload(bytes, length, type, ca, seed);
return IEC104_AsduQueue_Enqueue(&f->queue, f->queue.connection_generation,
IEC104_ASDU_PRIORITY_NORMAL, bytes, length) == IEC104_ASDU_QUEUE_OK;
}
/**
* 功能:构造测试专用CA及Type30..40位图。
* 输入参数:ca——公共地址。
* 输出参数:无。
* 返回值:按指定公共地址构造的 NORMAL 条目筛选条件。
* 说明:通用队列只按位图匹配,实际业务名单由上层选择。
*/
static IEC104_AsduNormalFilter_t event_filter(uint16_t ca)
{
IEC104_AsduNormalFilter_t filter;
unsigned type;
memset(&filter, 0, sizeof(filter));
filter.common_address = ca;
for (type = 30U; type <= 40U; ++type) {
filter.type_bitmap[type / 8U] |= (uint8_t)(1U << (type % 8U));
}
return filter;
}
/**
* 功能:按逻辑条目偏移独立检查序号、提交标志、长度和完整原文,验证压缩后仍保持稳定顺序。
* 输入参数:f——测试夹具;offset——文件、记录或缓冲区偏移;serial——期望条目序号;submitted——期望条目是否已交接;type——协议类型或期望事件类型;ca——公共地址;seed——正文样本的起始字节;length——字节长度。
* 输出参数:无。
* 返回值:非零表示本次操作或检查通过;0 表示失败。
* 说明:检查不满足时由 CHECK 立即返回失败,不继续后续断言。
*/
static int check_filter_entry(Fixture *f, uint32_t offset, uint64_t serial, int submitted,
uint8_t type, uint16_t ca, uint8_t seed, uint16_t length)
{
IEC104_AsduHeadInfo_t info;
uint8_t expected[IEC104_MAX_ASDU_LEN], actual[IEC104_MAX_ASDU_LEN];
CHECK(IEC104_AsduQueue_Get_Entry_By_Offset(&f->queue, IEC104_ASDU_PRIORITY_NORMAL,
offset, &info) == IEC104_ASDU_QUEUE_OK);
CHECK(info.entry_id.entry_serial == serial && info.is_submitted == submitted && info.asdu_length == length);
CHECK(IEC104_AsduQueue_Copy_Asdu(&info, actual, sizeof(actual)) == IEC104_ASDU_QUEUE_OK);
filter_payload(expected, length, type, ca, seed);
CHECK(memcmp(expected, actual, length) == 0);
return 1;
}
/**
* 功能:把完整环整体旋转,保持逻辑布局与所有字段相互一致。
* 输入参数:f——测试夹具;amount——环缓冲旋转量(字节)。
* 输出参数:f——操作后的测试夹具和队列状态。
* 返回值:无。
* 说明:遍历每个物理起点,
* 覆盖头、CA字段、待ACK前缀以及长条目源/目标跨尾和重叠的组合。
*/
static void rotate_normal_ring(Fixture *f, uint32_t amount)
{
IEC104_AsduPriorityQueue_t *bucket = &f->queue.priority_queues[IEC104_ASDU_PRIORITY_NORMAL];
uint8_t bytes[sizeof(f->normal)];
uint32_t i;
memcpy(bytes, f->normal, sizeof(bytes));
for (i = 0U; i < bucket->byte_capacity; ++i) {
f->normal[(i + amount) % bucket->byte_capacity] = bytes[i];
}
bucket->head_index = (bucket->head_index + amount) % bucket->byte_capacity;
bucket->tail_index = (bucket->tail_index + amount) % bucket->byte_capacity;
bucket->unsubmitted_index = (bucket->unsubmitted_index + amount) % bucket->byte_capacity;
}
/**
* 功能:遍历环缓冲所有物理起点,清除匹配的待发条目。
* 输入参数:无。
* 输出参数:无。
* 返回值:非零表示本次操作或检查通过;0 表示失败。
* 说明:核对跨尾压缩、未匹配原文、HIGH及待ACK前缀。
* Rebind再次读取保留条目,防止清除后序号间隔破坏后续生命周期。
*/
static int filtered_discard_ring_overlap(void)
{
uint32_t offset, capacity = 5U * IEC104_ASDU_NORMAL_ENTRY_HEADER_LEN + 6U + 6U + 249U + 6U + 70U + 5U;
for (offset = 0U; offset < capacity; ++offset) {
Fixture f, before;
IEC104_AsduNormalFilter_t filter = event_filter(0x1234U);
IEC104_AsduQueueStatus_t status;
IEC104_AsduPriorityQueue_t *bucket;
uint32_t count = 777U, removed = 777U, prefix_size, i;
uint64_t ticket;
CHECK(init(&f, sizeof(f.high), capacity, 1U));
CHECK(enqueue_filter_value(&f, 30U, 0x1234U, 1U, 6U));
CHECK(remove_head(&f, IEC104_ASDU_PRIORITY_NORMAL, 0));
CHECK(enqueue_filter_value(&f, 31U, 0x1234U, 2U, 6U));
CHECK(enqueue_filter_value(&f, 36U, 0x1235U, 3U, 249U));
CHECK(enqueue_filter_value(&f, 40U, 0x1234U, 4U, 6U));
CHECK(enqueue_filter_value(&f, 1U, 0x1234U, 5U, 70U));
CHECK(tracked(&f, &ticket));
rotate_normal_ring(&f, offset);
CHECK(IEC104_AsduQueue_Limit_Normal_Send(&f.queue, 1U) == IEC104_ASDU_QUEUE_OK);
before = f;
CHECK(IEC104_AsduQueue_Count_Unsubmitted_Normal(&f.queue, 1U, &filter, &count) == IEC104_ASDU_QUEUE_OK);
CHECK(count == 2U && memcmp(&f, &before, sizeof(f)) == 0);
CHECK(IEC104_AsduQueue_Discard_Unsubmitted_Normal(&f.queue, 1U, &filter, &removed) == IEC104_ASDU_QUEUE_OK);
CHECK(removed == 2U && f.queue.discarded_asdu_count == 2U);
bucket = &f.queue.priority_queues[IEC104_ASDU_PRIORITY_NORMAL];
CHECK(bucket->entry_count == 3U && bucket->unsubmitted_count == 2U);
CHECK(bucket->used_bytes == 3U * IEC104_ASDU_NORMAL_ENTRY_HEADER_LEN + 325U);
CHECK(f.queue.next_entry_serial == 6U && f.queue.normal_send_limited == 1U);
CHECK(memcmp(f.high, before.high, sizeof(f.high)) == 0);
CHECK(IEC104_AsduQueue_Get_Response_State(&f.queue, ticket) == IEC104_RESPONSE_PENDING);
prefix_size = IEC104_ASDU_NORMAL_ENTRY_HEADER_LEN + 6U;
for (i = 0U; i < prefix_size; ++i) {
CHECK(f.normal[(offset + i) % capacity] == before.normal[(offset + i) % capacity]);
}
CHECK(check_filter_entry(&f, 0U, 1U, 1, 30U, 0x1234U, 1U, 6U));
CHECK(check_filter_entry(&f, 1U, 3U, 0, 36U, 0x1235U, 3U, 249U));
CHECK(check_filter_entry(&f, 2U, 5U, 0, 1U, 0x1234U, 5U, 70U));
CHECK(IEC104_AsduQueue_Get_Status(&f.queue, &status) == IEC104_ASDU_QUEUE_OK);
CHECK(status.discarded_asdu_count == 2U && status.retained_unacked_count[IEC104_ASDU_PRIORITY_NORMAL] == 1U);
/* Rebind必须接受清除产生的编号间隔,并保持已保留原文。 */
CHECK(IEC104_AsduQueue_Rebind(&f.queue, 2U) == IEC104_ASDU_QUEUE_OK);
CHECK(check_filter_entry(&f, 0U, 1U, 0, 30U, 0x1234U, 1U, 6U));
CHECK(check_filter_entry(&f, 1U, 3U, 0, 36U, 0x1235U, 3U, 249U));
CHECK(check_filter_entry(&f, 2U, 5U, 0, 1U, 0x1234U, 5U, 70U));
CHECK(f.queue.discarded_asdu_count == 2U && f.queue.next_entry_serial == 6U);
}
return 1;
}
/**
* 功能:依次清空待发后缀、确认保留前缀、重绑及离线清除。
* 输入参数:无。
* 输出参数:无。
* 返回值:非零表示本次操作或检查通过;0 表示失败。
* 说明:空结果和空环指针也须一致。
*/
static int filtered_discard_empty_and_offline(void)
{
Fixture f;
IEC104_AsduNormalFilter_t filter = event_filter(1U);
IEC104_AsduPriorityQueue_t *bucket;
IEC104_AsduHeadInfo_t prefix;
uint32_t count = 777U;
CHECK(init(&f, sizeof(f.high), sizeof(f.normal), 1U));
CHECK(enqueue_filter_value(&f, 30U, 1U, 1U, 6U));
CHECK(IEC104_AsduQueue_Peek_Head(&f.queue, IEC104_ASDU_PRIORITY_NORMAL, &prefix) == IEC104_ASDU_QUEUE_OK);
CHECK(remove_head(&f, IEC104_ASDU_PRIORITY_NORMAL, 0));
CHECK(enqueue_filter_value(&f, 40U, 1U, 2U, 6U));
CHECK(IEC104_AsduQueue_Discard_Unsubmitted_Normal(&f.queue, 1U, &filter, &count) == IEC104_ASDU_QUEUE_OK);
CHECK(count == 1U);
bucket = &f.queue.priority_queues[IEC104_ASDU_PRIORITY_NORMAL];
CHECK(bucket->entry_count == 1U && bucket->unsubmitted_count == 0U && bucket->unsubmitted_index == bucket->tail_index);
CHECK(IEC104_AsduQueue_Count_Unsubmitted_Normal(&f.queue, 1U, &filter, &count) == IEC104_ASDU_QUEUE_OK && count == 0U);
CHECK(IEC104_AsduQueue_Confirm_Next_Normal_Entry(&f.queue, IEC104_ASDU_PRIORITY_NORMAL, prefix.entry_id) == IEC104_ASDU_QUEUE_OK);
CHECK(enqueue_filter_value(&f, 31U, 1U, 3U, 6U));
CHECK(remove_head(&f, IEC104_ASDU_PRIORITY_NORMAL, 0));
/* 原连接已提交条目在Rebind后恢复待发,属于新连接的可清除范围。 */
CHECK(IEC104_AsduQueue_Rebind(&f.queue, 2U) == IEC104_ASDU_QUEUE_OK);
CHECK(IEC104_AsduQueue_Discard_Unsubmitted_Normal(&f.queue, 2U, &filter, &count) == IEC104_ASDU_QUEUE_OK && count == 1U);
CHECK(IEC104_AsduQueue_Detach(&f.queue, 2U) == IEC104_ASDU_QUEUE_OK);
CHECK(enqueue_filter_value(&f, 37U, 1U, 4U, 6U));
CHECK(IEC104_AsduQueue_Discard_Unsubmitted_Normal(&f.queue, 0U, &filter, &count) == IEC104_ASDU_QUEUE_OK && count == 1U);
CHECK(bucket->entry_count == 0U && bucket->used_bytes == 0U && bucket->head_index == 0U &&
bucket->tail_index == 0U && bucket->unsubmitted_index == 0U);
CHECK(f.queue.discarded_asdu_count == 3U && f.queue.next_entry_serial == 5U);
count = 777U;
CHECK(IEC104_AsduQueue_Discard_Unsubmitted_Normal(&f.queue, 0U, &filter, &count) == IEC104_ASDU_QUEUE_OK && count == 0U);
CHECK(f.queue.discarded_asdu_count == 3U);
return 1;
}
/**
* 功能:覆盖Type位图两端、不同CA和全零位图。
* 输入参数:无。
* 输出参数:无。
* 返回值:非零表示本次操作或检查通过;0 表示失败。
* 说明:无匹配时队列逐字节不变,完整256位范围仍可选择。
*/
static int filtered_discard_bitmap_and_no_match(void)
{
Fixture f, before;
IEC104_AsduNormalFilter_t filter = event_filter(65534U);
uint32_t count = 777U;
CHECK(init(&f, sizeof(f.high), sizeof(f.normal), 1U));
CHECK(enqueue_filter_value(&f, 29U, 65534U, 1U, 6U));
CHECK(enqueue_filter_value(&f, 30U, 65534U, 2U, 6U));
CHECK(enqueue_filter_value(&f, 40U, 65534U, 3U, 6U));
CHECK(enqueue_filter_value(&f, 41U, 65534U, 4U, 6U));
CHECK(enqueue_filter_value(&f, 30U, 1U, 5U, 6U));
CHECK(enqueue_filter_value(&f, 255U, 65534U, 6U, 6U));
CHECK(IEC104_AsduQueue_Discard_Unsubmitted_Normal(&f.queue, 1U, &filter, &count) == IEC104_ASDU_QUEUE_OK && count == 2U);
CHECK(check_filter_entry(&f, 0U, 1U, 0, 29U, 65534U, 1U, 6U));
CHECK(check_filter_entry(&f, 1U, 4U, 0, 41U, 65534U, 4U, 6U));
CHECK(check_filter_entry(&f, 2U, 5U, 0, 30U, 1U, 5U, 6U));
memset(filter.type_bitmap, 0, sizeof(filter.type_bitmap));
before = f;
CHECK(IEC104_AsduQueue_Count_Unsubmitted_Normal(&f.queue, 1U, &filter, &count) == IEC104_ASDU_QUEUE_OK && count == 0U);
CHECK(IEC104_AsduQueue_Discard_Unsubmitted_Normal(&f.queue, 1U, &filter, &count) == IEC104_ASDU_QUEUE_OK && count == 0U);
CHECK(memcmp(&f, &before, sizeof(f)) == 0);
/* 位图本身支持完整的256个Type,TIME_TAGGED名单由Slave封装决定。 */
filter.type_bitmap[31] = 0x80U;
CHECK(IEC104_AsduQueue_Discard_Unsubmitted_Normal(&f.queue, 1U, &filter, &count) == IEC104_ASDU_QUEUE_OK && count == 1U);
CHECK(f.queue.priority_queues[IEC104_ASDU_PRIORITY_NORMAL].entry_count == 3U && f.queue.discarded_asdu_count == 3U);
return 1;
}
/**
* 功能:先覆盖一条已提交NORMAL,再清除待发条目。
* 输入参数:无。
* 输出参数:无。
* 返回值:非零表示本次操作或检查通过;0 表示失败。
* 说明:覆盖待ACK账目必须保留到原序号被确认。
*/
static int filtered_discard_preserves_overwritten_ack(void)
{
Fixture f;
IEC104_AsduNormalFilter_t filter = event_filter(1U);
IEC104_AsduHeadInfo_t prefix;
uint32_t count;
CHECK(init(&f, sizeof(f.high), 2U * (IEC104_ASDU_NORMAL_ENTRY_HEADER_LEN + 6U), 1U));
CHECK(enqueue_filter_value(&f, 30U, 1U, 1U, 6U));
CHECK(IEC104_AsduQueue_Peek_Head(&f.queue, IEC104_ASDU_PRIORITY_NORMAL, &prefix) == IEC104_ASDU_QUEUE_OK);
CHECK(remove_head(&f, IEC104_ASDU_PRIORITY_NORMAL, 0));
CHECK(enqueue_filter_value(&f, 1U, 1U, 2U, 6U));
CHECK(enqueue_filter_value(&f, 30U, 1U, 3U, 6U));
CHECK(f.queue.overwritten_unacked_count == 1U);
CHECK(IEC104_AsduQueue_Discard_Unsubmitted_Normal(&f.queue, 1U, &filter, &count) == IEC104_ASDU_QUEUE_OK && count == 1U);
CHECK(f.queue.overwritten_unacked_count == 1U && f.queue.overwritten_unacked_serial_begin == 1U &&
f.queue.overwritten_unacked_serial_end == 1U);
CHECK(check_filter_entry(&f, 0U, 2U, 0, 1U, 1U, 2U, 6U));
filter.type_bitmap[0] = 0x02U;
CHECK(IEC104_AsduQueue_Discard_Unsubmitted_Normal(&f.queue, 1U, &filter, &count) == IEC104_ASDU_QUEUE_OK && count == 1U);
CHECK(f.queue.priority_queues[IEC104_ASDU_PRIORITY_NORMAL].entry_count == 0U && f.queue.overwritten_unacked_count == 1U);
CHECK(IEC104_AsduQueue_Confirm_Next_Normal_Entry(&f.queue, IEC104_ASDU_PRIORITY_NORMAL, prefix.entry_id) == IEC104_ASDU_QUEUE_OK);
CHECK(f.queue.overwritten_unacked_count == 0U && f.queue.discarded_asdu_count == 2U);
return 1;
}
/**
* 功能:用错误代次、非法过滤器及损坏的后续条目制造失败。
* 输入参数:无。
* 输出参数:无。
* 返回值:非零表示本次操作或检查通过;0 表示失败。
* 说明:输出哨兵和整份夹具保持原样,证明不会在完整预检前先删除前面的合法条目。
*/
static int filtered_discard_failure_is_atomic(void)
{
Fixture f, before;
IEC104_AsduNormalFilter_t filter = event_filter(1U);
IEC104_AsduNormalEntryHeader_t corrupt;
uint32_t count, index;
CHECK(init(&f, sizeof(f.high), sizeof(f.normal), 1U));
CHECK(enqueue_filter_value(&f, 30U, 1U, 1U, 6U));
CHECK(enqueue_filter_value(&f, 31U, 1U, 2U, 6U));
before = f;
count = 777U;
CHECK(IEC104_AsduQueue_Count_Unsubmitted_Normal(&f.queue, 2U, &filter, &count) == IEC104_ASDU_QUEUE_ERROR);
CHECK(count == 777U && memcmp(&f, &before, sizeof(f)) == 0);
CHECK(IEC104_AsduQueue_Discard_Unsubmitted_Normal(&f.queue, 2U, &filter, &count) == IEC104_ASDU_QUEUE_ERROR);
CHECK(count == 777U && memcmp(&f, &before, sizeof(f)) == 0);
filter.common_address = 0U;
CHECK(IEC104_AsduQueue_Discard_Unsubmitted_Normal(&f.queue, 1U, &filter, &count) == IEC104_ASDU_QUEUE_ERROR);
filter.common_address = UINT16_MAX;
CHECK(IEC104_AsduQueue_Count_Unsubmitted_Normal(&f.queue, 1U, &filter, &count) == IEC104_ASDU_QUEUE_ERROR);
CHECK(count == 777U && memcmp(&f, &before, sizeof(f)) == 0);
filter = event_filter(1U);
CHECK(IEC104_AsduQueue_Discard_Unsubmitted_Normal(&f.queue, 1U, &filter, NULL) == IEC104_ASDU_QUEUE_ERROR);
CHECK(memcmp(&f, &before, sizeof(f)) == 0);
/* 第二条损坏时,不得先删除第一条。 */
index = IEC104_ASDU_NORMAL_ENTRY_HEADER_LEN + 6U;
memcpy(&corrupt, f.normal + index, sizeof(corrupt));
corrupt.asdu_length = 5U;
memcpy(f.normal + index, &corrupt, sizeof(corrupt));
before = f;
CHECK(IEC104_AsduQueue_Count_Unsubmitted_Normal(&f.queue, 1U, &filter, &count) == IEC104_ASDU_QUEUE_ERROR);
CHECK(IEC104_AsduQueue_Discard_Unsubmitted_Normal(&f.queue, 1U, &filter, &count) == IEC104_ASDU_QUEUE_ERROR);
CHECK(count == 777U && memcmp(&f, &before, sizeof(f)) == 0);
/* 即使位图不匹配任何条目,仍须检查待ACK前缀。 */
CHECK(init(&f, sizeof(f.high), sizeof(f.normal), 1U));
CHECK(enqueue_filter_value(&f, 30U, 1U, 1U, 6U));
CHECK(remove_head(&f, IEC104_ASDU_PRIORITY_NORMAL, 0));
memcpy(&corrupt, f.normal, sizeof(corrupt));
corrupt.entry_state = 3U;
memcpy(f.normal, &corrupt, sizeof(corrupt));
memset(filter.type_bitmap, 0, sizeof(filter.type_bitmap));
before = f;
CHECK(IEC104_AsduQueue_Discard_Unsubmitted_Normal(&f.queue, 1U, &filter, &count) == IEC104_ASDU_QUEUE_ERROR);
CHECK(count == 777U && memcmp(&f, &before, sizeof(f)) == 0);
return 1;
}
/* ============================================================================
* [ENTRY/MAIN] 测试入口:队列布局、生命周期与失败路径
* ============================================================================ */
/**
* 功能:测试入口:队列布局、生命周期与失败路径
* 输入参数:无。
* 输出参数:无。
* 返回值:正常完成返回 0;参数、运行或断言失败以非零状态结束进程。
* 说明:接口保留参数仍按回调签名传入,未使用的参数不参与本辅助函数的处理。
*/
int main(void)
{
/* [RUN/LAYOUT] FIFO、跨环字节与双队列独立 */
int (*tests[])(void) = {mixed_fifo, independent_queues, wrapped_headers,
/* [RUN/LIFETIME] 覆盖、取消、EOF与队列编号 */
overwrite_and_discard_normal, precise_cancellation, lifecycle_and_eof, startup_gate_and_eof,
/* [RUN/ERRORS] 失败原子性与容量边界 */
normal_serials_independent_of_responses, overwrite_failure_is_atomic, capacity_exhaustion_and_output,
/* [RUN/FILTER] 按CA/类型清除、全环位置压缩、ACK前缀和失败原子性 */
filtered_discard_ring_overlap, filtered_discard_empty_and_offline, filtered_discard_bitmap_and_no_match,
filtered_discard_preserves_overwritten_ack, filtered_discard_failure_is_atomic};
unsigned index;
for (index = 0U; index < sizeof(tests) / sizeof(tests[0]); ++index) {
if (!tests[index]()) { return 1; }
}
printf("response queue: %u groups passed\n", index);
return 0;
}