/* 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 #include #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; }