886 lines
52 KiB
C
886 lines
52 KiB
C
/* Strict business scheduling: queue ordering, independent receipts and retained ACK identities. */
|
|
#include "IEC104_AsduQueue.h"
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
|
|
#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;
|
|
}
|