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