/* Strict business scheduling: queue ordering, independent receipts and retained ACK identities. */ #include "IEC104_AsduQueue.h" #include #include #define CHECK(x) do { if (!(x)) { fprintf(stderr, "%s:%d: %s\n", __func__, __LINE__, #x); return 0; } } while (0) typedef struct { IEC104_AsduQueue_t queue; IEC104_AsduQueuePriorityState_t priorities; uint8_t high[1024], normal[1024]; } Fixture; typedef struct { Fixture base; uint8_t slots[IEC104_ASDU_SOE_MAX_CAPACITY * IEC104_ASDU_SOE_SLOT_LEN]; uint64_t retired[32]; } SoeFixture; /** * 功能:用非零填充值初始化指定容量队列并绑定严格优先级状态,便于暴露未初始化字段。 * 输入参数:f——测试夹具;high——HIGH 队列容量(字节);normal——NORMAL 队列容量(字节);seed——初始队列序号。 * 输出参数:f——操作后的测试夹具和队列状态。 * 返回值:非零表示本次操作或检查通过;0 表示失败。 * 说明:本辅助入口用于构造或核对上述测试场景,相关状态保存在当前测试夹具中。 */ static int init(Fixture *f, uint32_t high, uint32_t normal, uint64_t seed) { memset(f, 0xa5, sizeof(*f)); return IEC104_AsduQueue_Init(&f->queue, f->high, high, f->normal, normal, 1U, seed) == IEC104_ASDU_QUEUE_OK && IEC104_AsduQueue_Bind_Priority_State(&f->queue, &f->priorities) == IEC104_ASDU_QUEUE_OK && IEC104_AsduQueue_Set_Strict_Priority(&f->queue, 1U) == IEC104_ASDU_QUEUE_OK; } /** * 功能:构造带marker的最小ASDU头及定长正文,供排序和字节完整性断言识别各条目。 * 输入参数:bytes——报文字节缓冲区;length——字节长度;marker——用于识别内容的标签字节。 * 输出参数:bytes——写入或读出的数据字节。 * 返回值:无。 * 说明:本辅助入口用于构造或核对上述测试场景,相关状态保存在当前测试夹具中。 */ static void make_value(uint8_t *bytes, uint16_t length, uint8_t marker) { memset(bytes, marker, length); bytes[0] = (uint8_t)(1U + marker % 3U); bytes[1] = 1U; bytes[2] = 3U; bytes[3] = marker; bytes[4] = 1U; bytes[5] = 0U; } /** * 功能:将标记ASDU按指定业务等级放入HIGH应答或NORMAL事件队列,HIGH分支返回票据。 * 输入参数:f——测试夹具;storage——HIGH/NORMAL 存储队列选择;rank——业务优先级;marker——用于识别内容的标签字节;length——字节长度;ticket——发送跟踪票据。 * 输出参数:f——操作后的测试夹具和队列状态;ticket——提交成功时返回的跟踪票据。 * 返回值:真实队列操作的结果枚举。 * 说明:本辅助入口用于构造或核对上述测试场景,相关状态保存在当前测试夹具中。 */ static IEC104_AsduQueueResult_t enqueue(Fixture *f, IEC104_AsduPriority_t storage, unsigned rank, uint8_t marker, uint16_t length, uint64_t *ticket) { uint8_t bytes[249]; make_value(bytes, length, marker); if (storage == IEC104_ASDU_PRIORITY_HIGH) { return IEC104_AsduQueue_Enqueue_Response_Priority(&f->queue, f->queue.connection_generation, bytes, length, ticket, (IEC104_BusinessPriority_t)rank); } return IEC104_AsduQueue_Enqueue_Priority(&f->queue, f->queue.connection_generation, storage, bytes, length, (IEC104_BusinessPriority_t)rank); } /** * 功能:从可能跨环的条目复制ASDU,与独立构造的期望长度及全部正文逐字节比较。 * 输入参数:info——发布结果或队首条目信息(只读);marker——用于识别内容的标签字节;length——字节长度。 * 输出参数:无。 * 返回值:非零表示条目长度及所有字节均符合期望,零表示不匹配。 * 说明:本辅助入口用于构造或核对上述测试场景,相关状态保存在当前测试夹具中。 */ static int info_value(const IEC104_AsduHeadInfo_t *info, uint8_t marker, uint16_t length) { uint8_t actual[249], expected[249]; make_value(expected, length, marker); return info->asdu_length == length && IEC104_AsduQueue_Copy_Asdu(info, actual, sizeof(actual)) == IEC104_ASDU_QUEUE_OK && memcmp(actual, expected, length) == 0; } /** * 功能:验证12级业务排序、同等级FIFO及各应答票据独立推进,NORMAL在ACK后才能释放。 * 输入参数:无。 * 输出参数:无。 * 返回值:非零表示本次操作或检查通过;0 表示失败。 * 说明:检查不满足时由 CHECK 立即返回失败,不继续后续断言。 */ static int all_ranks_and_receipts(void) { Fixture f; IEC104_AsduHeadInfo_t info; uint64_t first[13] = {0U}, second[13] = {0U}; unsigned rank; CHECK(init(&f, sizeof(f.high), sizeof(f.normal), 1U)); for (rank = 12U; rank != 0U; --rank) { CHECK(enqueue(&f, IEC104_ASDU_PRIORITY_HIGH, rank, (uint8_t)rank, 6U, &first[rank]) == IEC104_ASDU_QUEUE_OK); CHECK(enqueue(&f, IEC104_ASDU_PRIORITY_NORMAL, rank, (uint8_t)rank, 6U, NULL) == IEC104_ASDU_QUEUE_OK); } for (rank = 12U; rank != 0U; --rank) { CHECK(enqueue(&f, IEC104_ASDU_PRIORITY_HIGH, rank, (uint8_t)(rank + 12U), 6U, &second[rank]) == IEC104_ASDU_QUEUE_OK); } CHECK(IEC104_AsduQueue_Get_Response_State(&f.queue, first[12]) == IEC104_RESPONSE_PENDING); for (rank = 1U; rank <= 12U; ++rank) { CHECK(IEC104_AsduQueue_Peek_Unsubmitted(&f.queue, IEC104_ASDU_PRIORITY_HIGH, &info) == IEC104_ASDU_QUEUE_OK); CHECK(info.business_priority == (IEC104_BusinessPriority_t)rank && info.response_ticket == first[rank]); CHECK(info_value(&info, (uint8_t)rank, 6U)); CHECK(IEC104_AsduQueue_Mark_Submitted(&f.queue, info.priority, info.entry_id) == IEC104_ASDU_QUEUE_OK); CHECK(IEC104_AsduQueue_Get_Response_State(&f.queue, first[rank]) == IEC104_RESPONSE_HANDED); CHECK(IEC104_AsduQueue_Get_Response_State(&f.queue, second[rank]) == IEC104_RESPONSE_PENDING); if (rank != 12U) { CHECK(IEC104_AsduQueue_Get_Response_State(&f.queue, first[12]) == IEC104_RESPONSE_PENDING); } CHECK(IEC104_AsduQueue_Peek_Unsubmitted(&f.queue, IEC104_ASDU_PRIORITY_HIGH, &info) == IEC104_ASDU_QUEUE_OK); CHECK(info.response_ticket == second[rank] && info_value(&info, (uint8_t)(rank + 12U), 6U)); CHECK(IEC104_AsduQueue_Mark_Submitted(&f.queue, info.priority, info.entry_id) == IEC104_ASDU_QUEUE_OK); CHECK(IEC104_AsduQueue_Peek_Unsubmitted(&f.queue, IEC104_ASDU_PRIORITY_NORMAL, &info) == IEC104_ASDU_QUEUE_OK); CHECK(info.business_priority == (IEC104_BusinessPriority_t)rank && info.response_ticket == 0U); CHECK(IEC104_AsduQueue_Mark_Submitted(&f.queue, info.priority, info.entry_id) == IEC104_ASDU_QUEUE_OK); CHECK(IEC104_AsduQueue_Confirm_Next_Normal_Entry(&f.queue, info.priority, info.entry_id) == IEC104_ASDU_QUEUE_OK); CHECK(IEC104_AsduQueue_Confirm_Next_Normal_Entry(&f.queue, info.priority, info.entry_id) == IEC104_ASDU_QUEUE_ERROR); } CHECK(f.queue.priority_queues[IEC104_ASDU_PRIORITY_HIGH].used_bytes == 0U); CHECK(f.queue.priority_queues[IEC104_ASDU_PRIORITY_NORMAL].used_bytes == 0U); return 1; } /** * 功能:验证直接发送票据与队列取消历史互不混淆,重初始化使用新种子后不复用旧身份。 * 输入参数:无。 * 输出参数:无。 * 返回值:非零表示本次操作或检查通过;0 表示失败。 * 说明:检查不满足时由 CHECK 立即返回失败,不继续后续断言。 */ static int direct_cancel_and_reuse(void) { Fixture f; IEC104_AsduHeadInfo_t info; uint64_t low, high, direct, next, old_direct; CHECK(init(&f, 50U, sizeof(f.normal), 1U)); CHECK(enqueue(&f, IEC104_ASDU_PRIORITY_HIGH, 12U, 12U, 6U, &low) == IEC104_ASDU_QUEUE_OK); CHECK(enqueue(&f, IEC104_ASDU_PRIORITY_HIGH, 12U, 13U, 6U, &next) == IEC104_ASDU_QUEUE_OK); CHECK(IEC104_AsduQueue_Can_Record_Direct_Response(&f.queue, 1U, IEC104_BUSINESS_PRIORITY_COMMAND) == IEC104_ASDU_QUEUE_OK); CHECK(IEC104_AsduQueue_Record_Direct_Response(&f.queue, 1U, IEC104_BUSINESS_PRIORITY_COMMAND, &direct) == IEC104_ASDU_QUEUE_OK); CHECK(IEC104_AsduQueue_Get_Response_State(&f.queue, direct) == IEC104_RESPONSE_HANDED); CHECK(IEC104_AsduQueue_Can_Record_Direct_Response(&f.queue, 1U, IEC104_BUSINESS_PRIORITY_COUNTER_INTERROGATION) == IEC104_ASDU_QUEUE_FULL); CHECK(IEC104_AsduQueue_Reset_High(&f.queue, 1U) == IEC104_ASDU_QUEUE_OK); CHECK(IEC104_AsduQueue_Get_Response_State(&f.queue, direct) == IEC104_RESPONSE_HANDED); CHECK(IEC104_AsduQueue_Get_Response_State(&f.queue, low) == IEC104_RESPONSE_CANCELLED); CHECK(IEC104_AsduQueue_Get_Response_State(&f.queue, next) == IEC104_RESPONSE_CANCELLED); CHECK(enqueue(&f, IEC104_ASDU_PRIORITY_HIGH, 12U, 14U, 6U, &low) == IEC104_ASDU_QUEUE_OK); CHECK(enqueue(&f, IEC104_ASDU_PRIORITY_HIGH, 3U, 3U, 6U, &high) == IEC104_ASDU_QUEUE_OK); CHECK(IEC104_AsduQueue_Peek_Unsubmitted(&f.queue, IEC104_ASDU_PRIORITY_HIGH, &info) == IEC104_ASDU_QUEUE_OK); CHECK(info.response_ticket == high); CHECK(IEC104_AsduQueue_Mark_Submitted(&f.queue, info.priority, info.entry_id) == IEC104_ASDU_QUEUE_OK); CHECK(IEC104_AsduQueue_Reset_High(&f.queue, 1U) == IEC104_ASDU_QUEUE_OK); CHECK(IEC104_AsduQueue_Get_Response_State(&f.queue, high) == IEC104_RESPONSE_HANDED); CHECK(IEC104_AsduQueue_Get_Response_State(&f.queue, low) == IEC104_RESPONSE_CANCELLED); next = f.queue.high_next_sequence; old_direct = direct; CHECK(init(&f, 50U, sizeof(f.normal), next)); CHECK(IEC104_AsduQueue_Get_Response_State(&f.queue, high) == IEC104_RESPONSE_CANCELLED); CHECK(IEC104_AsduQueue_Record_Direct_Response(&f.queue, 1U, IEC104_BUSINESS_PRIORITY_COMMAND, &direct) == IEC104_ASDU_QUEUE_OK); CHECK(direct > old_direct && direct >= next); CHECK(IEC104_AsduQueue_Get_Response_State(&f.queue, direct + 16U) == IEC104_RESPONSE_ERROR); return 1; } /** * 功能:覆盖未ACK正文后仍按原身份确认。 * 输入参数:无。 * 输出参数:无。 * 返回值:非零表示本次操作或检查通过;0 表示失败。 * 说明:空间不足的入队须保持整个队列原子不变。 */ static int overwritten_identity_and_full_atomicity(void) { Fixture f, before; IEC104_AsduHeadInfo_t info; IEC104_AsduEntryId_t low, high; IEC104_AsduQueueStatus_t status; CHECK(init(&f, sizeof(f.high), 96U, 1U)); CHECK(enqueue(&f, IEC104_ASDU_PRIORITY_NORMAL, 8U, 8U, 24U, NULL) == IEC104_ASDU_QUEUE_OK); CHECK(enqueue(&f, IEC104_ASDU_PRIORITY_NORMAL, 4U, 4U, 24U, NULL) == IEC104_ASDU_QUEUE_OK); CHECK(IEC104_AsduQueue_Peek_Unsubmitted(&f.queue, IEC104_ASDU_PRIORITY_NORMAL, &info) == IEC104_ASDU_QUEUE_OK); high = info.entry_id; CHECK(IEC104_AsduQueue_Mark_Submitted(&f.queue, info.priority, high) == IEC104_ASDU_QUEUE_OK); CHECK(IEC104_AsduQueue_Peek_Unsubmitted(&f.queue, IEC104_ASDU_PRIORITY_NORMAL, &info) == IEC104_ASDU_QUEUE_OK); low = info.entry_id; CHECK(IEC104_AsduQueue_Mark_Submitted(&f.queue, info.priority, low) == IEC104_ASDU_QUEUE_OK); CHECK(enqueue(&f, IEC104_ASDU_PRIORITY_NORMAL, 6U, 6U, 40U, NULL) == IEC104_ASDU_QUEUE_OK); CHECK(IEC104_AsduQueue_Get_Status(&f.queue, &status) == IEC104_ASDU_QUEUE_OK); CHECK(status.overwritten_unacked_count == 2U && status.entry_count[IEC104_ASDU_PRIORITY_NORMAL] == 1U); CHECK(IEC104_AsduQueue_Confirm_Next_Normal_Entry(&f.queue, IEC104_ASDU_PRIORITY_NORMAL, high) == IEC104_ASDU_QUEUE_OK); CHECK(IEC104_AsduQueue_Confirm_Next_Normal_Entry(&f.queue, IEC104_ASDU_PRIORITY_NORMAL, high) == IEC104_ASDU_QUEUE_ERROR); CHECK(IEC104_AsduQueue_Confirm_Next_Normal_Entry(&f.queue, IEC104_ASDU_PRIORITY_NORMAL, low) == IEC104_ASDU_QUEUE_OK); CHECK(IEC104_AsduQueue_Peek_Head(&f.queue, IEC104_ASDU_PRIORITY_NORMAL, &info) == IEC104_ASDU_QUEUE_OK); CHECK(info_value(&info, 6U, 40U)); CHECK(init(&f, sizeof(f.high), 40U, 1U)); CHECK(enqueue(&f, IEC104_ASDU_PRIORITY_NORMAL, 4U, 1U, 24U, NULL) == IEC104_ASDU_QUEUE_OK); CHECK(IEC104_AsduQueue_Peek_Unsubmitted(&f.queue, IEC104_ASDU_PRIORITY_NORMAL, &info) == IEC104_ASDU_QUEUE_OK); CHECK(IEC104_AsduQueue_Mark_Submitted(&f.queue, info.priority, info.entry_id) == IEC104_ASDU_QUEUE_OK); before = f; CHECK(enqueue(&f, IEC104_ASDU_PRIORITY_NORMAL, 4U, 2U, 24U, NULL) == IEC104_ASDU_QUEUE_FULL); CHECK(memcmp(&f, &before, sizeof(f)) == 0); CHECK(IEC104_AsduQueue_Confirm_Next_Normal_Entry(&f.queue, info.priority, info.entry_id) == IEC104_ASDU_QUEUE_OK); CHECK(enqueue(&f, IEC104_ASDU_PRIORITY_NORMAL, 4U, 2U, 24U, NULL) == IEC104_ASDU_QUEUE_OK); return 1; } /** * 功能:验证启动门、NORMAL发送限制、按类型丢弃及重绑定规则,旧代次身份不能继续确认。 * 输入参数:无。 * 输出参数:无。 * 返回值:非零表示本次操作或检查通过;0 表示失败。 * 说明:检查不满足时由 CHECK 立即返回失败,不继续后续断言。 */ static int gates_rebind_and_filter(void) { Fixture f; IEC104_AsduHeadInfo_t info; IEC104_AsduEntryId_t old; IEC104_AsduNormalFilter_t filter; uint32_t count; uint64_t ticket; CHECK(init(&f, sizeof(f.high), 128U, 1U)); CHECK(enqueue(&f, IEC104_ASDU_PRIORITY_NORMAL, 8U, 1U, 12U, NULL) == IEC104_ASDU_QUEUE_OK); CHECK(enqueue(&f, IEC104_ASDU_PRIORITY_NORMAL, 4U, 2U, 12U, NULL) == IEC104_ASDU_QUEUE_OK); CHECK(enqueue(&f, IEC104_ASDU_PRIORITY_NORMAL, 6U, 3U, 12U, NULL) == IEC104_ASDU_QUEUE_OK); CHECK(IEC104_AsduQueue_Peek_Unsubmitted(&f.queue, IEC104_ASDU_PRIORITY_NORMAL, &info) == IEC104_ASDU_QUEUE_OK); old = info.entry_id; CHECK(IEC104_AsduQueue_Mark_Submitted(&f.queue, info.priority, old) == IEC104_ASDU_QUEUE_OK); memset(&filter, 0, sizeof(filter)); filter.common_address = 1U; filter.type_bitmap[0] = 0xffU; CHECK(IEC104_AsduQueue_Count_Unsubmitted_Normal(&f.queue, 1U, &filter, &count) == IEC104_ASDU_QUEUE_OK && count == 2U); CHECK(IEC104_AsduQueue_Discard_Unsubmitted_Normal(&f.queue, 1U, &filter, &count) == IEC104_ASDU_QUEUE_OK && count == 2U); CHECK(IEC104_AsduQueue_Set_Startup_Pending(&f.queue, 1U, 1U) == IEC104_ASDU_QUEUE_OK); CHECK(enqueue(&f, IEC104_ASDU_PRIORITY_NORMAL, 6U, 4U, 12U, NULL) == IEC104_ASDU_QUEUE_OK); CHECK(enqueue(&f, IEC104_ASDU_PRIORITY_HIGH, 1U, 5U, 6U, &ticket) == IEC104_ASDU_QUEUE_OK); CHECK(IEC104_AsduQueue_Peek_Unsubmitted(&f.queue, IEC104_ASDU_PRIORITY_NORMAL, &info) == IEC104_ASDU_QUEUE_EMPTY); CHECK(IEC104_AsduQueue_Peek_Unsubmitted(&f.queue, IEC104_ASDU_PRIORITY_HIGH, &info) == IEC104_ASDU_QUEUE_OK); CHECK(IEC104_AsduQueue_Limit_Normal_Send(&f.queue, 1U) == IEC104_ASDU_QUEUE_OK); CHECK(IEC104_AsduQueue_Set_Startup_Pending(&f.queue, 1U, 0U) == IEC104_ASDU_QUEUE_OK); CHECK(IEC104_AsduQueue_Peek_Unsubmitted(&f.queue, IEC104_ASDU_PRIORITY_NORMAL, &info) == IEC104_ASDU_QUEUE_EMPTY); CHECK(IEC104_AsduQueue_Set_Startup_Pending(&f.queue, 1U, 1U) == IEC104_ASDU_QUEUE_OK); 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.strict_business_priority == 1U && f.queue.startup_pending == 1U && f.queue.normal_send_limited == 0U); CHECK(IEC104_AsduQueue_Confirm_Next_Normal_Entry(&f.queue, IEC104_ASDU_PRIORITY_NORMAL, old) == IEC104_ASDU_QUEUE_ERROR); 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, &info) == IEC104_ASDU_QUEUE_OK); CHECK(info.entry_id.entry_serial == old.entry_serial && info_value(&info, 2U, 12U)); return 1; } /* A plain ordered array models original storage order independently of the ring implementation. */ typedef struct { uint64_t serial; unsigned rank, state; uint16_t length; uint8_t marker; } ModelEntry; typedef struct { ModelEntry entries[32]; unsigned count; uint64_t next; } Model; /** * 功能:独立模型按条目头加剩余正文计算占用,已覆盖但待ACK的身份仍占头部空间。 * 输入参数:m——独立队列参考模型(只读)。 * 输出参数:无。 * 返回值:参考模型中条目头及剩余正文占用的总字节数。 * 说明:本辅助入口用于构造或核对上述测试场景,相关状态保存在当前测试夹具中。 */ static uint32_t model_used(const Model *m) { unsigned i; uint32_t used = 0U; for (i = 0U; i < m->count; ++i) { used += IEC104_ASDU_NORMAL_ENTRY_HEADER_LEN + m->entries[i].length; } return used; } /** * 功能:删除模型中已验证下标的条目并压紧数组,保持其余条目的原始存储顺序。 * 输入参数:m——独立队列参考模型;at——模型条目下标。 * 输出参数:m——删除条目并压紧后的参考模型。 * 返回值:无。 * 说明:本辅助入口用于构造或核对上述测试场景,相关状态保存在当前测试夹具中。 */ static void model_remove(Model *m, unsigned at) { memmove(&m->entries[at], &m->entries[at + 1U], (m->count - at - 1U) * sizeof(m->entries[0])); --m->count; } /** * 功能:选择模型中尚未提交的最高业务优先级,同级保留先入顺序。 * 输入参数:m——独立队列参考模型(只读)。 * 输出参数:无。 * 返回值:最高优先级待发送条目的下标;无候选时返回模型 count。 * 说明:没有候选时返回count。 */ static unsigned model_best(const Model *m) { unsigned i, best = m->count; for (i = 0U; i < m->count; ++i) { if (m->entries[i].state == 1U && (best == m->count || m->entries[i].rank < m->entries[best].rank)) { best = i; } } return best; } /** * 功能:将真实环队列的正文、身份、待发/待ACK计数和剩余空间逐项对照独立数组模型。 * 输入参数:f——测试夹具;m——独立队列参考模型(只读)。 * 输出参数:无。 * 返回值:非零表示本次操作或检查通过;0 表示失败。 * 说明:检查不满足时由 CHECK 立即返回失败,不继续后续断言。 */ static int model_check(Fixture *f, const Model *m) { IEC104_AsduQueueStatus_t status; IEC104_AsduHeadInfo_t info; unsigned i, offset = 0U, pending = 0U, retained = 0U, overwritten = 0U; uint32_t free_bytes; CHECK(IEC104_AsduQueue_Get_Status(&f->queue, &status) == IEC104_ASDU_QUEUE_OK); for (i = 0U; i < m->count; ++i) { const ModelEntry *entry = &m->entries[i]; if (entry->state == 3U) { ++overwritten; continue; } 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 == entry->serial && info.business_priority == (IEC104_BusinessPriority_t)entry->rank); CHECK(info.is_submitted == (entry->state == 2U) && info_value(&info, entry->marker, entry->length)); if (entry->state == 1U) { ++pending; } else { ++retained; } } CHECK(status.entry_count[IEC104_ASDU_PRIORITY_NORMAL] == offset && status.retained_unacked_count[IEC104_ASDU_PRIORITY_NORMAL] == retained && status.overwritten_unacked_count == overwritten); CHECK(f->queue.priority_queues[IEC104_ASDU_PRIORITY_NORMAL].unsubmitted_count == pending); CHECK(IEC104_AsduQueue_Get_Free_Bytes(&f->queue, IEC104_ASDU_PRIORITY_NORMAL, &free_bytes) == IEC104_ASDU_QUEUE_OK); CHECK(free_bytes == f->queue.priority_queues[IEC104_ASDU_PRIORITY_NORMAL].byte_capacity - model_used(m)); return 1; } /** * 功能:固定线性同余递推,使随机操作序列可重现。 * 输入参数:state——状态值。 * 输出参数:state——递推更新后的随机种子。 * 返回值:更新后的可复现伪随机值。 * 说明:更新种子并返回下一值。 */ static uint32_t random_next(uint32_t *state) { *state = *state * 1664525U + 1013904223U; return *state; } /** * 功能:在固定种子的两万次入队、提交、ACK、过滤和重绑定操作后逐步核对保留队列模型。 * 输入参数:无。 * 输出参数:无。 * 返回值:非零表示本次操作或检查通过;0 表示失败。 * 说明:检查不满足时由 CHECK 立即返回失败,不继续后续断言。 */ static int random_retained_model(void) { Fixture f, before; Model model; uint32_t random = 0x711294U; unsigned step; memset(&model, 0, sizeof(model)); model.next = 1U; CHECK(init(&f, sizeof(f.high), 193U, 1U)); for (step = 0U; step < 20000U; ++step) { unsigned operation = (random_next(&random) >> 24) % 8U; if (operation < 4U) { Model prepared = model; uint16_t length = (uint16_t)(6U + random_next(&random) % 36U); unsigned rank = 1U + random_next(&random) % 12U, at = 0U; uint8_t marker = (uint8_t)random_next(&random); uint32_t needed = IEC104_ASDU_NORMAL_ENTRY_HEADER_LEN + length; IEC104_AsduQueueResult_t result; while (193U - model_used(&prepared) < needed && at < prepared.count) { if (prepared.entries[at].state == 1U) { model_remove(&prepared, at); } else { if (prepared.entries[at].state == 2U) { prepared.entries[at].state = 3U; prepared.entries[at].length = 0U; } ++at; } } before = f; result = enqueue(&f, IEC104_ASDU_PRIORITY_NORMAL, rank, marker, length, NULL); if (193U - model_used(&prepared) < needed) { CHECK(result == IEC104_ASDU_QUEUE_FULL && memcmp(&f, &before, sizeof(f)) == 0); } else { ModelEntry *entry = &prepared.entries[prepared.count++]; CHECK(result == IEC104_ASDU_QUEUE_OK); entry->serial = prepared.next++; entry->rank = rank; entry->state = 1U; entry->length = length; entry->marker = marker; model = prepared; } } else if (operation == 4U) { IEC104_AsduHeadInfo_t info; unsigned best = model_best(&model); IEC104_AsduQueueResult_t result = IEC104_AsduQueue_Peek_Unsubmitted(&f.queue, IEC104_ASDU_PRIORITY_NORMAL, &info); if (best == model.count) { CHECK(result == IEC104_ASDU_QUEUE_EMPTY); } else { CHECK(result == IEC104_ASDU_QUEUE_OK && info.entry_id.entry_serial == model.entries[best].serial); CHECK(IEC104_AsduQueue_Mark_Submitted(&f.queue, info.priority, info.entry_id) == IEC104_ASDU_QUEUE_OK); model.entries[best].state = 2U; } } else if (operation == 5U && model.count != 0U) { unsigned at = random_next(&random) % model.count; IEC104_AsduEntryId_t id = {f.queue.connection_generation, model.entries[at].serial}; IEC104_AsduQueueResult_t result = IEC104_AsduQueue_Confirm_Next_Normal_Entry(&f.queue, IEC104_ASDU_PRIORITY_NORMAL, id); if (model.entries[at].state == 1U) { CHECK(result == IEC104_ASDU_QUEUE_ERROR); } else { CHECK(result == IEC104_ASDU_QUEUE_OK); model_remove(&model, at); CHECK(IEC104_AsduQueue_Confirm_Next_Normal_Entry(&f.queue, IEC104_ASDU_PRIORITY_NORMAL, id) == IEC104_ASDU_QUEUE_ERROR); } } else if (operation == 6U) { IEC104_AsduNormalFilter_t filter; uint32_t removed, expected = 0U; unsigned at = 0U, type = 1U + random_next(&random) % 3U; memset(&filter, 0, sizeof(filter)); filter.common_address = 1U; filter.type_bitmap[0] = (uint8_t)(1U << type); CHECK(IEC104_AsduQueue_Discard_Unsubmitted_Normal(&f.queue, f.queue.connection_generation, &filter, &removed) == IEC104_ASDU_QUEUE_OK); while (at < model.count) { if (model.entries[at].state == 1U && 1U + model.entries[at].marker % 3U == type) { model_remove(&model, at); ++expected; } else { ++at; } } CHECK(removed == expected); } else if (operation == 7U) { unsigned at = 0U; uint64_t generation = f.queue.connection_generation; CHECK(IEC104_AsduQueue_Detach(&f.queue, generation) == IEC104_ASDU_QUEUE_OK); CHECK(IEC104_AsduQueue_Rebind(&f.queue, generation + 1U) == IEC104_ASDU_QUEUE_OK); while (at < model.count) { if (model.entries[at].state == 3U) { model_remove(&model, at); } else { model.entries[at++].state = 1U; } } } CHECK(model_check(&f, &model)); } return 1; } /** * 功能:验证非法业务等级及票据耗尽拒绝请求,并保持队列与失败输出的原状态。 * 输入参数:无。 * 输出参数:无。 * 返回值:非零表示本次操作或检查通过;0 表示失败。 * 说明:检查不满足时由 CHECK 立即返回失败,不继续后续断言。 */ static int invalid_inputs_and_exhaustion(void) { Fixture f, before; IEC104_AsduHeadInfo_t info; uint64_t ticket = 777U; CHECK(init(&f, sizeof(f.high), sizeof(f.normal), UINT64_MAX - 63U)); CHECK(IEC104_AsduQueue_Record_Direct_Response(&f.queue, 1U, IEC104_BUSINESS_PRIORITY_INITIALIZATION, &ticket) == IEC104_ASDU_QUEUE_OK); CHECK(IEC104_AsduQueue_Record_Direct_Response(&f.queue, 1U, IEC104_BUSINESS_PRIORITY_INITIALIZATION, &ticket) == IEC104_ASDU_QUEUE_OK); CHECK(IEC104_AsduQueue_Record_Direct_Response(&f.queue, 1U, IEC104_BUSINESS_PRIORITY_INITIALIZATION, &ticket) == IEC104_ASDU_QUEUE_OK); before = f; CHECK(IEC104_AsduQueue_Record_Direct_Response(&f.queue, 1U, IEC104_BUSINESS_PRIORITY_INITIALIZATION, &ticket) == IEC104_ASDU_QUEUE_ERROR); CHECK(memcmp(&f, &before, sizeof(f)) == 0); CHECK(init(&f, sizeof(f.high), sizeof(f.normal), 1U)); before = f; CHECK(enqueue(&f, IEC104_ASDU_PRIORITY_HIGH, 0U, 1U, 6U, &ticket) == IEC104_ASDU_QUEUE_ERROR); CHECK(enqueue(&f, IEC104_ASDU_PRIORITY_NORMAL, 13U, 1U, 6U, NULL) == IEC104_ASDU_QUEUE_ERROR); CHECK(memcmp(&f, &before, sizeof(f)) == 0); CHECK(enqueue(&f, IEC104_ASDU_PRIORITY_HIGH, 3U, 1U, 6U, &ticket) == IEC104_ASDU_QUEUE_OK); CHECK(IEC104_AsduQueue_Set_Strict_Priority(&f.queue, 0U) == IEC104_ASDU_QUEUE_ERROR); CHECK(IEC104_AsduQueue_Peek_Head(&f.queue, IEC104_ASDU_PRIORITY_HIGH, &info) == IEC104_ASDU_QUEUE_OK); /* Corrupt the stored rank without changing control metadata: every mutating entry must fail atomically. */ f.high[18] = 2U; before = f; CHECK(IEC104_AsduQueue_Reset_High(&f.queue, 1U) == IEC104_ASDU_QUEUE_ERROR); CHECK(IEC104_AsduQueue_Rebind(&f.queue, 2U) == IEC104_ASDU_QUEUE_ERROR); CHECK(enqueue(&f, IEC104_ASDU_PRIORITY_NORMAL, 4U, 1U, 6U, NULL) == IEC104_ASDU_QUEUE_ERROR); CHECK(memcmp(&f, &before, sizeof(f)) == 0); return 1; } /** * 功能:反复环绕HIGH区域并对照待发送模型,核对应答票据和同等级多轮取消历史的状态。 * 输入参数:无。 * 输出参数:无。 * 返回值:非零表示本次操作或检查通过;0 表示失败。 * 说明:检查不满足时由 CHECK 立即返回失败,不继续后续断言。 */ static int high_wrap_and_cancel_history(void) { Fixture f; Model pending; uint32_t random = 0x993249U; unsigned step, wraps = 0U; uint64_t previous_tail = 0U; memset(&pending, 0, sizeof(pending)); CHECK(init(&f, 113U, sizeof(f.normal), 1U)); for (step = 0U; step < 6000U; ++step) { unsigned operation = (random_next(&random) >> 24) % 5U; if (operation < 3U) { uint64_t ticket = 777U; unsigned rank = 1U + random_next(&random) % 12U; uint16_t length = (uint16_t)(6U + random_next(&random) % 20U); uint8_t marker = (uint8_t)random_next(&random); IEC104_AsduQueueResult_t result = enqueue(&f, IEC104_ASDU_PRIORITY_HIGH, rank, marker, length, &ticket); if (result == IEC104_ASDU_QUEUE_FULL) { CHECK(ticket == 777U); } else { ModelEntry *entry = &pending.entries[pending.count++]; CHECK(result == IEC104_ASDU_QUEUE_OK); entry->serial = ticket; entry->rank = rank; entry->state = 1U; entry->length = length; entry->marker = marker; } } else if (operation == 3U && pending.count != 0U) { IEC104_AsduHeadInfo_t info; unsigned best = model_best(&pending); uint64_t ticket = pending.entries[best].serial; CHECK(IEC104_AsduQueue_Peek_Unsubmitted(&f.queue, IEC104_ASDU_PRIORITY_HIGH, &info) == IEC104_ASDU_QUEUE_OK); CHECK(info.response_ticket == ticket && info_value(&info, pending.entries[best].marker, pending.entries[best].length)); CHECK(IEC104_AsduQueue_Mark_Submitted(&f.queue, info.priority, info.entry_id) == IEC104_ASDU_QUEUE_OK); CHECK(IEC104_AsduQueue_Get_Response_State(&f.queue, ticket) == IEC104_RESPONSE_HANDED); model_remove(&pending, best); } else if (operation == 4U && pending.count != 0U) { IEC104_AsduHeadInfo_t info; uint64_t ticket = pending.entries[0].serial; CHECK(IEC104_AsduQueue_Peek_Head(&f.queue, IEC104_ASDU_PRIORITY_HIGH, &info) == IEC104_ASDU_QUEUE_OK); CHECK(info.response_ticket == ticket); CHECK(IEC104_AsduQueue_Discard_Unsubmitted_Head(&f.queue, info.priority, info.entry_id) == IEC104_ASDU_QUEUE_OK); CHECK(IEC104_AsduQueue_Get_Response_State(&f.queue, ticket) == IEC104_RESPONSE_CANCELLED); model_remove(&pending, 0U); } { unsigned i; IEC104_AsduQueueStatus_t status; CHECK(IEC104_AsduQueue_Get_Status(&f.queue, &status) == IEC104_ASDU_QUEUE_OK); CHECK(status.entry_count[IEC104_ASDU_PRIORITY_HIGH] == pending.count); for (i = 0U; i < pending.count; ++i) { IEC104_AsduHeadInfo_t info; CHECK(IEC104_AsduQueue_Get_Entry_By_Offset(&f.queue, IEC104_ASDU_PRIORITY_HIGH, i, &info) == IEC104_ASDU_QUEUE_OK); CHECK(info.response_ticket == pending.entries[i].serial && info_value(&info, pending.entries[i].marker, pending.entries[i].length)); CHECK(IEC104_AsduQueue_Get_Response_State(&f.queue, pending.entries[i].serial) == IEC104_RESPONSE_PENDING); } } if (f.queue.priority_queues[IEC104_ASDU_PRIORITY_HIGH].tail_index < previous_tail && pending.count != 0U) { ++wraps; } previous_tail = f.queue.priority_queues[IEC104_ASDU_PRIORITY_HIGH].tail_index; } CHECK(wraps > 100U); /* A second cancellation of the same lane forgets only older uncertain history. */ { uint64_t cancelled, handed, cancelled_again; IEC104_AsduHeadInfo_t info; CHECK(IEC104_AsduQueue_Reset_High(&f.queue, 1U) == IEC104_ASDU_QUEUE_OK); CHECK(enqueue(&f, IEC104_ASDU_PRIORITY_HIGH, 3U, 1U, 6U, &cancelled) == IEC104_ASDU_QUEUE_OK); CHECK(IEC104_AsduQueue_Reset_High(&f.queue, 1U) == IEC104_ASDU_QUEUE_OK); CHECK(enqueue(&f, IEC104_ASDU_PRIORITY_HIGH, 3U, 2U, 6U, &handed) == IEC104_ASDU_QUEUE_OK); CHECK(IEC104_AsduQueue_Peek_Unsubmitted(&f.queue, IEC104_ASDU_PRIORITY_HIGH, &info) == IEC104_ASDU_QUEUE_OK); CHECK(IEC104_AsduQueue_Mark_Submitted(&f.queue, info.priority, info.entry_id) == IEC104_ASDU_QUEUE_OK); CHECK(enqueue(&f, IEC104_ASDU_PRIORITY_HIGH, 3U, 3U, 6U, &cancelled_again) == IEC104_ASDU_QUEUE_OK); CHECK(IEC104_AsduQueue_Reset_High(&f.queue, 1U) == IEC104_ASDU_QUEUE_OK); CHECK(IEC104_AsduQueue_Get_Response_State(&f.queue, cancelled) == IEC104_RESPONSE_CANCELLED); CHECK(IEC104_AsduQueue_Get_Response_State(&f.queue, handed) == IEC104_RESPONSE_HANDED); CHECK(IEC104_AsduQueue_Get_Response_State(&f.queue, cancelled_again) == IEC104_RESPONSE_CANCELLED); } return 1; } /** * 功能:验证HIGH/NORMAL共用单调准入顺序,已保留NORMAL条目在重绑定后仍保有原顺序。 * 输入参数:无。 * 输出参数:无。 * 返回值:非零表示本次操作或检查通过;0 表示失败。 * 说明:检查不满足时由 CHECK 立即返回失败,不继续后续断言。 */ static int shared_admission_order(void) { Fixture f; IEC104_AsduHeadInfo_t high, normal; uint64_t ticket, previous; CHECK(init(&f, sizeof(f.high), sizeof(f.normal), 1U)); CHECK(enqueue(&f, IEC104_ASDU_PRIORITY_NORMAL, 6U, 1U, 6U, NULL) == IEC104_ASDU_QUEUE_OK); CHECK(enqueue(&f, IEC104_ASDU_PRIORITY_HIGH, 6U, 2U, 6U, &ticket) == IEC104_ASDU_QUEUE_OK); CHECK(IEC104_AsduQueue_Peek_Unsubmitted(&f.queue, IEC104_ASDU_PRIORITY_NORMAL, &normal) == IEC104_ASDU_QUEUE_OK); CHECK(IEC104_AsduQueue_Peek_Unsubmitted(&f.queue, IEC104_ASDU_PRIORITY_HIGH, &high) == IEC104_ASDU_QUEUE_OK); CHECK(normal.admission_order < high.admission_order && normal.admission_order == normal.entry_id.entry_serial); previous = high.admission_order; CHECK(IEC104_AsduQueue_Mark_Submitted(&f.queue, normal.priority, normal.entry_id) == IEC104_ASDU_QUEUE_OK); CHECK(IEC104_AsduQueue_Confirm_Next_Normal_Entry(&f.queue, normal.priority, normal.entry_id) == IEC104_ASDU_QUEUE_OK); CHECK(enqueue(&f, IEC104_ASDU_PRIORITY_NORMAL, 6U, 3U, 6U, NULL) == IEC104_ASDU_QUEUE_OK); CHECK(IEC104_AsduQueue_Peek_Unsubmitted(&f.queue, IEC104_ASDU_PRIORITY_NORMAL, &normal) == IEC104_ASDU_QUEUE_OK); CHECK(normal.admission_order > previous); CHECK(IEC104_AsduQueue_Detach(&f.queue, 1U) == IEC104_ASDU_QUEUE_OK); CHECK(IEC104_AsduQueue_Rebind(&f.queue, 2U) == IEC104_ASDU_QUEUE_OK); previous = normal.admission_order; CHECK(IEC104_AsduQueue_Peek_Unsubmitted(&f.queue, IEC104_ASDU_PRIORITY_NORMAL, &normal) == IEC104_ASDU_QUEUE_OK); CHECK(normal.admission_order == previous); CHECK(enqueue(&f, IEC104_ASDU_PRIORITY_HIGH, 6U, 4U, 6U, &ticket) == IEC104_ASDU_QUEUE_OK); CHECK(IEC104_AsduQueue_Peek_Unsubmitted(&f.queue, IEC104_ASDU_PRIORITY_HIGH, &high) == IEC104_ASDU_QUEUE_OK); CHECK(high.admission_order > previous); return 1; } /** * 功能:初始化小容量或完整256槽SOE夹具,兼容和严格模式共用同一外借存储。 * 输入参数:f——夹具;strict——模式;capacity/retired——SOE槽及退休身份容量。 * 输出参数:f——已绑定两个NORMAL存储区的队列。 * 返回值:1成功,0失败。 * 说明:先清空队列再切模式,不让旧结构或编号残留影响覆盖断言。 */ static int soe_init(SoeFixture *f, unsigned strict, uint16_t capacity, uint16_t retired) { memset(f, 0, sizeof(*f)); return init(&f->base, sizeof(f->base.high), sizeof(f->base.normal), 1U) && IEC104_AsduQueue_Set_Strict_Priority(&f->base.queue, (uint8_t)strict) == IEC104_ASDU_QUEUE_OK && IEC104_AsduQueue_Bind_Soe_Storage(&f->base.queue, f->slots, capacity, f->retired, retired) == IEC104_ASDU_QUEUE_OK; } /** * 功能:构造同一IOA上的单对象Type30/31原文,标记分布在OA、值和CP56中。 * 输入参数:bytes——17字节输出;marker——区分事件内容;type——30或31。 * 输出参数:bytes——完整独立期望报文,TEST置位且品质、时标IV保留。 * 返回值:无。 * 说明:同点多次事件不得由被测队列去重;时标格式有效但允许IV。 */ static void soe_value(uint8_t *bytes, uint8_t marker, uint8_t type) { static const uint8_t original[17] = {30U, 1U, 0x83U, 0U, 1U, 0U, 0x71U, 0x17U, 0U, 0x81U, 0U, 0U, 0x80U, 12U, 14U, 11U, 26U}; memcpy(bytes, original, sizeof(original)); bytes[0] = type; bytes[3] = marker; bytes[10] = marker; } /** * 功能:验证256个同点独立事件全部保留,普通NORMAL洪泛不侵占SOE,第257条仅覆盖最旧SOE。 * 输入参数:无。 * 输出参数:无。 * 返回值:1通过,0断言失败。 * 说明:两种模式逐字节检查Type30/31、TEST、OA、CA、IOA、品质和CP56,并检查聚合状态及普通区空闲。 */ static int soe_capacity_and_isolation(void) { static SoeFixture f; unsigned mode, i; for (mode = 0U; mode < 2U; ++mode) { IEC104_AsduQueue_t *q = &f.base.queue; IEC104_AsduSoeStatus_t state; IEC104_AsduQueueStatus_t aggregate; IEC104_AsduHeadInfo_t head; uint8_t bytes[17], actual[17]; uint64_t serial, first = 0U, second = 0U; uint32_t free_bytes, soe_sent = 0U, other_sent = 0U; CHECK(soe_init(&f, mode, 256U, 32U)); soe_value(bytes, 0x5aU, 30U); for (i = 0U; i < 256U; ++i) { CHECK(IEC104_AsduQueue_Enqueue_Soe(q, 1U, bytes, sizeof(bytes), IEC104_BUSINESS_PRIORITY_SEQUENCE_EVENT, false, &serial) == IEC104_ASDU_QUEUE_OK); if (i == 0U) { first = serial; } if (i == 1U) { second = serial; } } CHECK(IEC104_AsduQueue_Get_Soe_Status(q, &state) == IEC104_ASDU_QUEUE_OK && state.stored_count == 256U && state.pending_count == 256U && state.dropped_pending_count == 0U); CHECK(IEC104_AsduQueue_Get_Free_Bytes(q, IEC104_ASDU_PRIORITY_NORMAL, &free_bytes) == IEC104_ASDU_QUEUE_OK && free_bytes == sizeof(f.base.normal)); for (i = 0U; i < 80U; ++i) { CHECK(enqueue(&f.base, IEC104_ASDU_PRIORITY_NORMAL, 8U, (uint8_t)i, 249U, NULL) == IEC104_ASDU_QUEUE_OK); } CHECK(IEC104_AsduQueue_Peek_Head(q, IEC104_ASDU_PRIORITY_NORMAL, &head) == IEC104_ASDU_QUEUE_OK && head.entry_id.entry_serial == first); CHECK(IEC104_AsduQueue_Copy_Asdu(&head, actual, sizeof(actual)) == IEC104_ASDU_QUEUE_OK && memcmp(actual, bytes, sizeof(bytes)) == 0); soe_value(bytes, 0x6bU, 31U); CHECK(IEC104_AsduQueue_Enqueue_Soe(q, 1U, bytes, sizeof(bytes), IEC104_BUSINESS_PRIORITY_SEQUENCE_EVENT, false, &serial) == IEC104_ASDU_QUEUE_OK); CHECK(IEC104_AsduQueue_Peek_Head(q, IEC104_ASDU_PRIORITY_NORMAL, &head) == IEC104_ASDU_QUEUE_OK && head.entry_id.entry_serial == second); CHECK(IEC104_AsduQueue_Get_Soe_Status(q, &state) == IEC104_ASDU_QUEUE_OK && state.stored_count == 256U && state.dropped_pending_count == 1U); CHECK(IEC104_AsduQueue_Get_Status(q, &aggregate) == IEC104_ASDU_QUEUE_OK && aggregate.entry_count[IEC104_ASDU_PRIORITY_NORMAL] > 256U && !aggregate.is_storage_empty); CHECK(IEC104_AsduQueue_Get_Entry_By_Offset(q, IEC104_ASDU_PRIORITY_NORMAL, aggregate.entry_count[IEC104_ASDU_PRIORITY_NORMAL] - 1U, &head) == IEC104_ASDU_QUEUE_OK && head.entry_id.entry_serial == serial); CHECK(IEC104_AsduQueue_Copy_Asdu(&head, actual, sizeof(actual)) == IEC104_ASDU_QUEUE_OK && memcmp(actual, bytes, sizeof(bytes)) == 0); for (i = 0U; i < aggregate.entry_count[IEC104_ASDU_PRIORITY_NORMAL]; ++i) { CHECK(IEC104_AsduQueue_Peek_Unsubmitted(q, IEC104_ASDU_PRIORITY_NORMAL, &head) == IEC104_ASDU_QUEUE_OK); if (head.asdu_first[0] == 30U || head.asdu_first[0] == 31U) { ++soe_sent; } else { ++other_sent; } CHECK(IEC104_AsduQueue_Mark_Submitted(q, head.priority, head.entry_id) == IEC104_ASDU_QUEUE_OK); CHECK(IEC104_AsduQueue_Confirm_Next_Normal_Entry(q, head.priority, head.entry_id) == IEC104_ASDU_QUEUE_OK); } CHECK(soe_sent == 256U && other_sent == aggregate.entry_count[IEC104_ASDU_PRIORITY_NORMAL] - 256U); CHECK(IEC104_AsduQueue_Peek_Unsubmitted(q, IEC104_ASDU_PRIORITY_NORMAL, &head) == IEC104_ASDU_QUEUE_EMPTY); } return 1; } /** * 功能:验证在途SOE覆盖保留精确身份,退休表满时原子拒绝,旧ACK不删除复用槽中的新事件。 * 输入参数:无。 * 输出参数:无。 * 返回值:1通过,0失败。 * 说明:两种模式覆盖两条待ACK事件,检查重复ACK、状态汇总以及失败时全部存储不变。 */ static int soe_retired_ack_and_atomicity(void) { static SoeFixture f, before; unsigned mode; for (mode = 0U; mode < 2U; ++mode) { IEC104_AsduQueue_t *q = &f.base.queue; IEC104_AsduHeadInfo_t head; IEC104_AsduEntryId_t a, b; IEC104_AsduSoeStatus_t state; uint64_t serial; uint8_t bytes[17]; CHECK(soe_init(&f, mode, 2U, 1U)); soe_value(bytes, 1U, 30U); CHECK(IEC104_AsduQueue_Enqueue_Soe(q, 1U, bytes, 17U, IEC104_BUSINESS_PRIORITY_SEQUENCE_EVENT, false, &serial) == IEC104_ASDU_QUEUE_OK); CHECK(IEC104_AsduQueue_Peek_Unsubmitted(q, IEC104_ASDU_PRIORITY_NORMAL, &head) == IEC104_ASDU_QUEUE_OK); a = head.entry_id; CHECK(IEC104_AsduQueue_Mark_Submitted(q, head.priority, a) == IEC104_ASDU_QUEUE_OK); bytes[3] = 2U; CHECK(IEC104_AsduQueue_Enqueue_Soe(q, 1U, bytes, 17U, IEC104_BUSINESS_PRIORITY_SEQUENCE_EVENT, false, &serial) == IEC104_ASDU_QUEUE_OK); CHECK(IEC104_AsduQueue_Peek_Unsubmitted(q, IEC104_ASDU_PRIORITY_NORMAL, &head) == IEC104_ASDU_QUEUE_OK); b = head.entry_id; CHECK(IEC104_AsduQueue_Mark_Submitted(q, head.priority, b) == IEC104_ASDU_QUEUE_OK); bytes[3] = 3U; CHECK(IEC104_AsduQueue_Enqueue_Soe(q, 1U, bytes, 17U, IEC104_BUSINESS_PRIORITY_SEQUENCE_EVENT, false, &serial) == IEC104_ASDU_QUEUE_OK); before = f; serial = UINT64_MAX; CHECK(IEC104_AsduQueue_Enqueue_Soe(q, 1U, bytes, 17U, IEC104_BUSINESS_PRIORITY_SEQUENCE_EVENT, false, &serial) == IEC104_ASDU_QUEUE_FULL); CHECK(serial == UINT64_MAX && memcmp(&before, &f, sizeof(f)) == 0); CHECK(IEC104_AsduQueue_Confirm_Next_Normal_Entry(q, IEC104_ASDU_PRIORITY_NORMAL, a) == IEC104_ASDU_QUEUE_OK); CHECK(IEC104_AsduQueue_Confirm_Next_Normal_Entry(q, IEC104_ASDU_PRIORITY_NORMAL, a) == IEC104_ASDU_QUEUE_ERROR); bytes[3] = 4U; CHECK(IEC104_AsduQueue_Enqueue_Soe(q, 1U, bytes, 17U, IEC104_BUSINESS_PRIORITY_SEQUENCE_EVENT, false, &serial) == IEC104_ASDU_QUEUE_OK); CHECK(IEC104_AsduQueue_Confirm_Next_Normal_Entry(q, IEC104_ASDU_PRIORITY_NORMAL, b) == IEC104_ASDU_QUEUE_OK); CHECK(IEC104_AsduQueue_Get_Soe_Status(q, &state) == IEC104_ASDU_QUEUE_OK && state.stored_count == 2U && state.pending_count == 2U && state.retired_count == 0U && state.overwritten_unacked_count == 2U); CHECK(IEC104_AsduQueue_Peek_Head(q, IEC104_ASDU_PRIORITY_NORMAL, &head) == IEC104_ASDU_QUEUE_OK && head.asdu_first[3] == 3U); } return 1; } /** * 功能:验证占位只阻挡后续同级SOE,发布、取消及CA/Type清除均不复生旧身份。 * 输入参数:无。 * 输出参数:无。 * 返回值:1通过,0失败。 * 说明:两模式均检查更早事件先发、其他等级可推进、门禁、重连保留占位及清除后的EMPTY。 */ static int soe_deferred_filter_and_rebind(void) { static SoeFixture f; unsigned mode; for (mode = 0U; mode < 2U; ++mode) { IEC104_AsduQueue_t *q = &f.base.queue; IEC104_AsduHeadInfo_t head; IEC104_AsduEntryId_t old; IEC104_AsduSoeStatus_t state; IEC104_AsduNormalFilter_t filter; uint8_t bytes[17]; uint64_t early, deferred, later, other; uint32_t count; CHECK(soe_init(&f, mode, 8U, 4U)); soe_value(bytes, 1U, 30U); CHECK(IEC104_AsduQueue_Enqueue_Soe(q, 1U, bytes, 17U, IEC104_BUSINESS_PRIORITY_SEQUENCE_EVENT, false, &early) == IEC104_ASDU_QUEUE_OK); CHECK(IEC104_AsduQueue_Enqueue_Soe(q, 1U, bytes, 17U, IEC104_BUSINESS_PRIORITY_SEQUENCE_EVENT, true, &deferred) == IEC104_ASDU_QUEUE_OK); CHECK(IEC104_AsduQueue_Enqueue_Soe(q, 1U, bytes, 17U, IEC104_BUSINESS_PRIORITY_SEQUENCE_EVENT, false, &later) == IEC104_ASDU_QUEUE_OK); bytes[4] = 2U; CHECK(IEC104_AsduQueue_Enqueue_Soe(q, 1U, bytes, 17U, IEC104_BUSINESS_PRIORITY_FAULT_EVENT, false, &other) == IEC104_ASDU_QUEUE_OK); CHECK(IEC104_AsduQueue_Peek_Unsubmitted(q, IEC104_ASDU_PRIORITY_NORMAL, &head) == IEC104_ASDU_QUEUE_OK && head.entry_id.entry_serial == early); old = head.entry_id; CHECK(IEC104_AsduQueue_Mark_Submitted(q, head.priority, head.entry_id) == IEC104_ASDU_QUEUE_OK); CHECK(IEC104_AsduQueue_Peek_Unsubmitted(q, IEC104_ASDU_PRIORITY_NORMAL, &head) == IEC104_ASDU_QUEUE_OK && head.entry_id.entry_serial == other); CHECK(IEC104_AsduQueue_Mark_Submitted(q, head.priority, head.entry_id) == IEC104_ASDU_QUEUE_OK); CHECK(IEC104_AsduQueue_Peek_Unsubmitted(q, IEC104_ASDU_PRIORITY_NORMAL, &head) == IEC104_ASDU_QUEUE_EMPTY); CHECK(IEC104_AsduQueue_Get_Soe_Status(q, &state) == IEC104_ASDU_QUEUE_OK && state.pending_count == 1U && state.deferred_count == 1U && state.retained_unacked_count == 2U); CHECK(IEC104_AsduQueue_Detach(q, 1U) == IEC104_ASDU_QUEUE_OK); CHECK(IEC104_AsduQueue_Set_Startup_Pending(q, 0U, 1U) == IEC104_ASDU_QUEUE_OK); CHECK(IEC104_AsduQueue_Rebind(q, 2U) == IEC104_ASDU_QUEUE_OK); CHECK(IEC104_AsduQueue_Peek_Unsubmitted(q, IEC104_ASDU_PRIORITY_NORMAL, &head) == IEC104_ASDU_QUEUE_EMPTY); CHECK(IEC104_AsduQueue_Confirm_Next_Normal_Entry(q, IEC104_ASDU_PRIORITY_NORMAL, old) == IEC104_ASDU_QUEUE_ERROR); CHECK(IEC104_AsduQueue_Set_Startup_Pending(q, 2U, 0U) == IEC104_ASDU_QUEUE_OK); CHECK(IEC104_AsduQueue_Resolve_Soe(q, deferred, true) == IEC104_ASDU_QUEUE_OK); CHECK(IEC104_AsduQueue_Resolve_Soe(q, deferred, true) == IEC104_ASDU_QUEUE_EMPTY); memset(&filter, 0, sizeof(filter)); filter.common_address = 1U; filter.type_bitmap[30U / 8U] = 1U << (30U % 8U); CHECK(IEC104_AsduQueue_Count_Unsubmitted_Normal(q, 2U, &filter, &count) == IEC104_ASDU_QUEUE_OK && count == 3U); CHECK(IEC104_AsduQueue_Discard_Unsubmitted_Normal(q, 2U, &filter, &count) == IEC104_ASDU_QUEUE_OK && count == 3U); CHECK(IEC104_AsduQueue_Resolve_Soe(q, deferred, false) == IEC104_ASDU_QUEUE_EMPTY); bytes[4] = 1U; CHECK(IEC104_AsduQueue_Enqueue_Soe(q, 2U, bytes, 17U, IEC104_BUSINESS_PRIORITY_SEQUENCE_EVENT, true, &deferred) == IEC104_ASDU_QUEUE_OK); CHECK(IEC104_AsduQueue_Count_Unsubmitted_Normal(q, 2U, &filter, &count) == IEC104_ASDU_QUEUE_OK && count == 1U); CHECK(IEC104_AsduQueue_Discard_Unsubmitted_Normal(q, 2U, &filter, &count) == IEC104_ASDU_QUEUE_OK && count == 1U); CHECK(IEC104_AsduQueue_Resolve_Soe(q, deferred, true) == IEC104_ASDU_QUEUE_EMPTY); CHECK(IEC104_AsduQueue_Get_Soe_Status(q, &state) == IEC104_ASDU_QUEUE_OK && state.stored_count == 1U && state.discarded_count == 4U); } return 1; } /** * 功能:验证SOE错误输入不产生副作用,覆盖占位后不能复生,全局编号耗尽拒绝入队。 * 输入参数:无。 * 输出参数:无。 * 返回值:1通过,0失败。 * 说明:固定形状校验不替代生产者的CP56业务校验;普通NORMAL入队也不能绕回共享身份。 */ static int soe_invalid_and_exhaustion(void) { static SoeFixture f, before; unsigned mode, variant; for (mode = 0U; mode < 2U; ++mode) { IEC104_AsduQueue_t *q = &f.base.queue; uint8_t bytes[17]; uint64_t serial, deferred; CHECK(soe_init(&f, mode, 1U, 1U)); for (variant = 0U; variant < 7U; ++variant) { soe_value(bytes, 1U, 30U); if (variant == 0U) { bytes[0] = 32U; } if (variant == 1U) { bytes[1] = 2U; } if (variant == 2U) { bytes[1] = 0x81U; } if (variant == 3U) { bytes[2] = 0x43U; } if (variant == 4U) { bytes[2] = 5U; } if (variant == 5U) { bytes[4] = 0U; } if (variant == 6U) { bytes[6] = bytes[7] = 0U; } before = f; serial = UINT64_MAX; CHECK(IEC104_AsduQueue_Enqueue_Soe(q, 1U, bytes, 17U, IEC104_BUSINESS_PRIORITY_SEQUENCE_EVENT, false, &serial) == IEC104_ASDU_QUEUE_ERROR); CHECK(serial == UINT64_MAX && memcmp(&before, &f, sizeof(f)) == 0); } soe_value(bytes, 2U, 31U); CHECK(IEC104_AsduQueue_Enqueue_Soe(q, 1U, bytes, 17U, IEC104_BUSINESS_PRIORITY_SEQUENCE_EVENT, true, &deferred) == IEC104_ASDU_QUEUE_OK); CHECK(IEC104_AsduQueue_Enqueue_Soe(q, 1U, bytes, 17U, IEC104_BUSINESS_PRIORITY_SEQUENCE_EVENT, false, &serial) == IEC104_ASDU_QUEUE_OK); CHECK(IEC104_AsduQueue_Resolve_Soe(q, deferred, true) == IEC104_ASDU_QUEUE_EMPTY); q->next_entry_serial = UINT64_MAX; before = f; CHECK(IEC104_AsduQueue_Enqueue_Soe(q, 1U, bytes, 17U, IEC104_BUSINESS_PRIORITY_SEQUENCE_EVENT, false, &serial) == IEC104_ASDU_QUEUE_FULL); CHECK(enqueue(&f.base, IEC104_ASDU_PRIORITY_NORMAL, 8U, 4U, 17U, NULL) == IEC104_ASDU_QUEUE_FULL); CHECK(memcmp(&before, &f, sizeof(f)) == 0); } return 1; } /** * 功能:验证已ACK的SOE身份不会落入普通NORMAL覆盖编号区间的空洞。 * 输入参数:无。 * 输出参数:无。 * 返回值:1通过,0失败。 * 说明:普通在途A、SOE、普通在途B形成交错身份;覆盖A/B后重放SOE的ACK必须无副作用。 */ static int soe_ack_routing_gap(void) { static SoeFixture f, before; unsigned mode, i; for (mode = 0U; mode < 2U; ++mode) { IEC104_AsduQueue_t *q = &f.base.queue; IEC104_AsduHeadInfo_t head; IEC104_AsduEntryId_t a, event, b; IEC104_AsduQueueStatus_t state; uint8_t bytes[17]; uint64_t serial; CHECK(soe_init(&f, mode, 2U, 2U)); CHECK(enqueue(&f.base, IEC104_ASDU_PRIORITY_NORMAL, 4U, 1U, 17U, NULL) == IEC104_ASDU_QUEUE_OK); CHECK(IEC104_AsduQueue_Peek_Unsubmitted(q, IEC104_ASDU_PRIORITY_NORMAL, &head) == IEC104_ASDU_QUEUE_OK); a = head.entry_id; CHECK((a.entry_serial & 1U) == 0U && IEC104_AsduQueue_Mark_Submitted(q, head.priority, a) == IEC104_ASDU_QUEUE_OK); soe_value(bytes, 3U, 30U); CHECK(IEC104_AsduQueue_Enqueue_Soe(q, 1U, bytes, 17U, IEC104_BUSINESS_PRIORITY_SEQUENCE_EVENT, false, &serial) == IEC104_ASDU_QUEUE_OK); CHECK((serial & 1U) != 0U && serial > a.entry_serial); CHECK(IEC104_AsduQueue_Peek_Unsubmitted(q, IEC104_ASDU_PRIORITY_NORMAL, &head) == IEC104_ASDU_QUEUE_OK); event = head.entry_id; CHECK(IEC104_AsduQueue_Mark_Submitted(q, head.priority, event) == IEC104_ASDU_QUEUE_OK); CHECK(IEC104_AsduQueue_Confirm_Next_Normal_Entry(q, head.priority, event) == IEC104_ASDU_QUEUE_OK); CHECK(enqueue(&f.base, IEC104_ASDU_PRIORITY_NORMAL, 4U, 2U, 17U, NULL) == IEC104_ASDU_QUEUE_OK); CHECK(IEC104_AsduQueue_Peek_Unsubmitted(q, IEC104_ASDU_PRIORITY_NORMAL, &head) == IEC104_ASDU_QUEUE_OK); b = head.entry_id; CHECK((b.entry_serial & 1U) == 0U && b.entry_serial > serial); CHECK(IEC104_AsduQueue_Mark_Submitted(q, head.priority, b) == IEC104_ASDU_QUEUE_OK); for (i = 0U; i < 8U; ++i) { CHECK(enqueue(&f.base, IEC104_ASDU_PRIORITY_NORMAL, 8U, 4U, 249U, NULL) == IEC104_ASDU_QUEUE_OK); } CHECK(IEC104_AsduQueue_Get_Status(q, &state) == IEC104_ASDU_QUEUE_OK && state.overwritten_unacked_count == 2U); before = f; CHECK(IEC104_AsduQueue_Confirm_Next_Normal_Entry(q, IEC104_ASDU_PRIORITY_NORMAL, event) == IEC104_ASDU_QUEUE_ERROR); CHECK(memcmp(&before, &f, sizeof(f)) == 0); CHECK(IEC104_AsduQueue_Confirm_Next_Normal_Entry(q, IEC104_ASDU_PRIORITY_NORMAL, a) == IEC104_ASDU_QUEUE_OK); CHECK(IEC104_AsduQueue_Confirm_Next_Normal_Entry(q, IEC104_ASDU_PRIORITY_NORMAL, b) == IEC104_ASDU_QUEUE_OK); CHECK(IEC104_AsduQueue_Get_Status(q, &state) == IEC104_ASDU_QUEUE_OK && state.overwritten_unacked_count == 0U); } return 1; } /** * 功能:执行普通严格队列与紧凑SOE两种模式的全部核心回归。 * 输入参数:无。 * 输出参数:标准输出——成功组数;标准错误——首个失败位置。 * 返回值:全部通过为0,否则1。 * 说明:测试使用外借静态数组,不访问网络或持久介质。 */ int main(void) { int (*tests[])(void) = {all_ranks_and_receipts, direct_cancel_and_reuse, overwritten_identity_and_full_atomicity, gates_rebind_and_filter, random_retained_model, invalid_inputs_and_exhaustion, high_wrap_and_cancel_history, shared_admission_order, soe_capacity_and_isolation, soe_retired_ack_and_atomicity, soe_deferred_filter_and_rebind, soe_invalid_and_exhaustion, soe_ack_routing_gap}; unsigned i; for (i = 0U; i < sizeof(tests) / sizeof(tests[0]); ++i) { if (!tests[i]()) { return 1; } } printf("strict priority queue: %u groups passed\n", i); return 0; }