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

2678 lines
138 KiB
C
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
/*
* SystemCommand专项:可控Net/单调时钟,真实Slave、发送队列及ACK路径。
* 文件内导航(搜索方括号标记;Suite:SystemCommand):
* 公共夹具与注入之后集中请求/动作辅助,再依次阅读104、107、70、105以及跨类型故障与生命周期。
* [COMMON/FIXTURE] 固定服务、原站节点、模拟时钟和应用计数;
* [HOOKS] 提交/查询/清除结果注入,只影响指定边界,其余走真实库;
* [COMMON/LIFECYCLE] 建连、通知分派、有界推进和引用回收;
* [COMMON/WIRE] 手写APCI/ASDU、请求发送、输出收集及累计ACK;
* [COMMON/ACTION] 应用许可/清除、回调耗时和重入探针;
* [105/HELPERS] 复位等待、观察槽/原站资源与原请求身份检查;
* [105/CLEAR_HELPER] QRP2的独立NORMAL队列输入;
* [104/VALIDATION] 固定图样、校验优先级及原文回显;[104/FLOW] WAIT、混合FIFO、容量及会话清理;
* [TEST/FEATURE] 104/107共用功能开关;[107/VALIDATION] 校验顺序、规范化回显及静默丢弃;
* [70/ROUNDS] / [70/TRANSITIONS] 初始化策略、pending COI、空轮、独立WAIT及完成轮次;
* [105/VALIDATION] TEST、QRP和功能开关;[105/DECISION] 至多一次动作和期限;
* [105/ACK] / [105/PENDING_TIMEOUT] / [105/FIFO_CANCEL] / [105/QUERY_ERRORS] ACK期限、提交前否定、取消和查询故障;
* [105/SESSION_BOUNDARY] ACKED/READY/已交出承诺遇STOP及断线的六组边界;
* [105/ACK_ORDER] 同批ACK/STOP先后、迟到ACK、期限及跨重连的一次性交出;
* [105/CLOSE_BOUNDARY] READY跨服务Close保留;观察已清除时的错误及引用释放;
* [105/QRP2] 应用/库两层清除、CA与时标范围及部分失败;
* [105/PRIVATE] 专用限定词显式启用、原值透传、ACK后许可及广播屏障,禁止误清事件;
* [105/TEST] 标准/专用TEST协议模拟、广播肯定回显和WAIT,不调用动作、不清事件、不建立真实授权;
* [FAILURES] 跨类型发送结果与正常STOP让出;[LIFETIME] 引用、满槽、启停和重建;
* [ENTRY] 原执行顺序和容量矩阵用例登记,定义归拢不改变main的调用次序。
* 无真实socket或设备复位,生产编译不得带本文件的Test符号。
* system_groups统计实际执行的参数化场景,不把断言数或内部轮询次数算作组数。
*/
#include "iec104_test_config.h"
#include "iec104_tcp_fixture.h"
#include "IEC104_SystemCommand.h"
#ifndef IEC104_SYSTEM_COMMAND_TASK_CAPACITY
#define IEC104_SYSTEM_COMMAND_TASK_CAPACITY 4U
#endif
#ifndef IEC104_SYSTEM_COMMAND_CAPACITY
#define IEC104_SYSTEM_COMMAND_CAPACITY IEC104_TCP_SERVER_CAPACITY
#endif
/* [COMMON/FIXTURE] 每个用例独立建立服务;真实传输状态机保留窗口限制,fake Net不使用socket。
* 放宽链路期限只为隔离被测的决定/ACK业务期限,不代表部署时使用这些t1/t3值。 */
static IEC104_Slave_t *system_slave;
static IEC104_SystemCommand_t *system_command;
static IEC104_Station_t system_stations[3];
static IEC104_SystemCommandStatus_t system_status;
static IEC104_SlaveEvent_t system_input;
static IEC104_SlaveAckReceipt_t system_reset_receipt; /* 真实成功回执的只读副本,不替模块释放。 */
static IEC104_SystemCommandEventResult_t system_handled;
static unsigned system_ns, system_groups, action_calls, count_calls, discard_calls;
static uint8_t system_features = 15U;
static uint16_t system_window = 32U;
static IEC104_SystemCommandInitPolicy_t system_policy = IEC104_SYSTEM_COMMAND_INIT_ONCE;
static unsigned action_mode, application_cleared; /* mode:0许可、1拒绝、2非法枚举、3检查重入后许可。 */
static uint64_t action_advance, count_advance; /* 分别模拟回调耗时和队列预检耗时;不推进网络。 */
static int send_wait_type, send_failure, ack_submit_wait, count_failure, discard_failure;
static int handoff_override = -9, ack_override = -9; /* -9是测试哨兵:不覆盖,查询真实凭证/ACK。 */
static uint64_t ack_override_time;
static const uint8_t system_untimed_test_request[11] = {
104U, 1U, 6U, 0xa5U, 1U, 0U, 0U, 0U, 0U, 0xaaU, 0x55U
};
static const uint8_t system_test_request[18] = {
107U, 1U, 6U, 7U, 1U, 0U, 0U, 0U, 0U, 0x34U, 0x12U, 0U, 0U, 0U, 0U, 1U, 1U, 24U
};
static const uint8_t system_reset_request[10] = {105U, 1U, 6U, 8U, 1U, 0U, 0U, 0U, 0U, 1U};
static const uint8_t system_reset_confirmation[10] = {105U, 1U, 7U, 8U, 1U, 0U, 0U, 0U, 0U, 1U};
/* [HOOKS] WAIT不修改真实队列;ACK覆盖只影响查询,用真实receipt保证释放路径受检。
* send_failure=3在提交边界注入真实STOP,验证先让出通知;此处不是允许应用回调推进Slave。
* Count失败发生在应用动作之前;Discard失败发生在ACCEPT之后,分别验证无副作用与部分失败。 */
#ifdef IEC104_SYSTEM_COMMAND_TEST_HOOKS
/**
* 功能:提交边界的WAIT按Type注入。
* 输入参数:slave——被测 Slave 实例;identity——请求所属的 Slave、实例及连接代次身份(只读);asdu——ASDU 容器(只读);ticket——发送跟踪票据。
* 输出参数:ticket——提交成功时返回的跟踪票据。
* 返回值:发送提交结果,区分接收成功、WAIT、ERROR 与 FATAL。
* 说明:调用错误/致命错误对所有tracked提交注入,正常路径保留真实交接票据。
* 注入STOP先由Slave受理并留下通知,检查业务把会话终结交回FIFO分派。
*/
IEC104_TcpSubmitResult_t IEC104_SystemCommand_Test_Send_Response_Tracked(IEC104_Slave_t *slave,
const IEC104_SlaveEventIdentity_t *identity, const IEC60870_Asdu_t *asdu, uint64_t *ticket)
{
const uint8_t *bytes;
uint16_t length;
CHECK(IEC60870_Asdu_Get_Data(asdu, &bytes, &length) == IEC60870_ASDU_OK && length != 0U);
if (send_wait_type == bytes[0] || send_wait_type == 255) { return IEC104_TCP_SUBMIT_WAIT; }
if (send_failure == 1) { return IEC104_TCP_SUBMIT_ERROR; }
if (send_failure == 2) { return IEC104_TCP_SUBMIT_FATAL; }
if (send_failure == 3) {
push(stop_act, sizeof(stop_act));
CHECK(IEC104_Slave_Poll(slave, 0U, NULL) == IEC104_TCP_OK);
return IEC104_TCP_SUBMIT_ERROR;
}
return IEC104_Slave_Send_Response_Tracked(slave, identity, asdu, ticket);
}
/**
* 功能:QRP1肯定确认仍经真实ACK观察接口提交。
* 输入参数:slave——被测 Slave 实例;identity——请求所属的 Slave、实例及连接代次身份(只读);asdu——ASDU 容器(只读);receipt——带连接身份的 ACK 回执。
* 输出参数:receipt——提交成功时返回的 ACK 回执。
* 返回值:发送提交结果,区分接收成功、WAIT、ERROR 与 FATAL。
* 说明:成功才保存receipt副本用于资源断言。
* ack_submit_wait不创建观察槽,因此可检查重试前没有伪造的复位授权。
*/
IEC104_TcpSubmitResult_t IEC104_SystemCommand_Test_Send_Response_Acked(IEC104_Slave_t *slave,
const IEC104_SlaveEventIdentity_t *identity, const IEC60870_Asdu_t *asdu, IEC104_SlaveAckReceipt_t *receipt)
{
IEC104_TcpSubmitResult_t result;
if (ack_submit_wait) { return IEC104_TCP_SUBMIT_WAIT; }
result = IEC104_Slave_Send_Response_Acked(slave, identity, asdu, receipt);
if (result == IEC104_TCP_SUBMIT_OK) { system_reset_receipt = *receipt; }
return result;
}
/**
* 功能:固定票据状态只影响本次查询,用于复现交接等待和查询故障。
* 输入参数:slave——被测 Slave 实例(只读);ticket——发送跟踪票据。
* 输出参数:无。
* 返回值:响应票据状态,保留待交接、已交接及失效等区别。
* 说明:-9恢复真实状态。
*/
IEC104_ResponseState_t IEC104_SystemCommand_Test_Get_Response_State(const IEC104_Slave_t *slave,
uint64_t ticket)
{
if (handoff_override != -9) { return (IEC104_ResponseState_t)handoff_override; }
return IEC104_Slave_Get_Response_State(slave, ticket);
}
/**
* 功能:单独覆盖ACK状态和受理时刻,以隔离业务期限判断。
* 输入参数:slave——被测 Slave 实例(只读);receipt——带连接身份的 ACK 回执(只读);acked_at_ms——ACK 时刻(毫秒)的存储。
* 输出参数:acked_at_ms——已 ACK 时写入的确认时刻(毫秒)。
* 返回值:ACK 生命周期状态,区分排队、已发送、已确认及无效回执。
* 说明:会话顺序用例不用此钩子。
*/
IEC104_SlaveAckState_t IEC104_SystemCommand_Test_Get_Ack_State(const IEC104_Slave_t *slave,
const IEC104_SlaveAckReceipt_t *receipt, uint64_t *acked_at_ms)
{
if (ack_override != -9) {
if (ack_override == IEC104_SLAVE_ACK_ACKED && acked_at_ms != NULL) { *acked_at_ms = ack_override_time; }
return (IEC104_SlaveAckState_t)ack_override;
}
return IEC104_Slave_Get_Active_Ack_State(slave, receipt, acked_at_ms);
}
/**
* 功能:预检时增加模拟耗时或返回错误,检查应用清除动作是否仍有许可、尚未超期。
* 输入参数:slave——被测 Slave 实例(只读);ca——公共地址;kind——记录或对象类别;count——对象、条目或站点数量;error——底层错误码存储。
* 输出参数:count——匹配筛选条件的待发送事件数量;error——底层错误码存储。
* 返回值:真实传输接口或故障注入产生的 TCP 操作结果。
* 说明:本辅助入口用于构造或核对上述测试场景,相关状态保存在当前测试夹具中。
*/
IEC104_TcpResult_t IEC104_SystemCommand_Test_Count_Pending_Events(const IEC104_Slave_t *slave,
uint16_t ca, IEC104_SlaveEventClass_t kind, uint32_t *count, IEC104_TcpError_t *error)
{
++count_calls;
fake.now += count_advance;
if (count_failure) { return IEC104_TCP_INTERNAL_ERROR; }
return IEC104_Slave_Count_Pending_Events(slave, ca, kind, count, error);
}
/**
* 功能:在系统命令清除阶段注入失败或委托真实库清理待发送事件。
* 输入参数:slave——被测 Slave 实例;ca——公共地址;kind——记录或对象类别;removed——被清除条目数量的存储;error——底层错误码存储。
* 输出参数:removed——被清除条目数量的存储;error——底层错误码存储。
* 返回值:真实传输接口或故障注入产生的 TCP 操作结果。
* 说明:应用已接受后才可能到达库清除阶段;失败不撤回应用副作用,须报告部分失败。
*/
IEC104_TcpResult_t IEC104_SystemCommand_Test_Discard_Pending_Events(IEC104_Slave_t *slave,
uint16_t ca, IEC104_SlaveEventClass_t kind, uint32_t *removed, IEC104_TcpError_t *error)
{
++discard_calls;
if (discard_failure) { return IEC104_TCP_INTERNAL_ERROR; }
return IEC104_Slave_Discard_Pending_Events(slave, ca, kind, removed, error);
}
#endif
/**
* 功能:[COMMON/LIFECYCLE] 按FIFO分派所有Slave通知,复制最近I帧仅供诊断/重入探针,
* 不保留NextEvent的借用指针。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:此处只交付通知,不自动执行业务动作。
*/
static void system_drain(void)
{
IEC104_SlaveEvent_t event;
IEC104_TcpEventResult_t next;
while ((next = IEC104_Slave_NextEvent(system_slave, &event)) == IEC104_TCP_EVENT_READY) {
IEC104_SystemCommandEventResult_t handled = IEC104_SystemCommand_Handle_Event(system_command, &event);
CHECK(handled != IEC104_SYSTEM_COMMAND_EVENT_ERROR);
if (event.transport.type == IEC104_TCP_EVENT_I_FRAME) {
CHECK(IEC104_Slave_Copy_Event(&system_input, &event));
system_handled = handled;
}
}
CHECK(next == IEC104_TCP_EVENT_EMPTY);
}
/**
* 功能:推进一次真实传输并读空生命周期通知。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:失败输出当前参数化场景,便于定位故障注入。
*/
static void system_poll(void)
{
IEC104_TcpResult_t result = IEC104_Slave_Poll(system_slave, 0U, NULL);
if (result != IEC104_TCP_OK) {
fprintf(stderr, "SystemCommand poll group=%u now=%llu action=%u result=%d\n",
system_groups, (unsigned long long)fake.now, action_mode, (int)result);
}
CHECK(result == IEC104_TCP_OK);
system_drain();
}
/**
* 功能:统一刷新只读快照。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:错误输出不变的场景直接调用API,避免本辅助提前断言成功。
*/
static void system_get_status(void)
{
CHECK(IEC104_SystemCommand_Get_Status(system_command, &system_status));
}
/**
* 功能:有界推进网络及Process,刻意不调用Execute_Next、不自动ACK。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:只有用例明确调用才触发动作。
* 因此本辅助不能证明复位已就绪,相关用例仍须核对状态和Take_Reset的结果。
*/
static void system_flush(void)
{
unsigned i;
for (i = 0U; i < 12U; ++i) {
system_poll();
CHECK(IEC104_SystemCommand_Process(system_command));
}
system_get_status();
}
/**
* 功能:每个场景重置注入计数并建立STARTED会话,决定/ACK期限由调用方独立给定。
* 输入参数:decision_ms——动作决策期限(毫秒);ack_ms——ACK 等待期限(毫秒)。
* 输出参数:无。
* 返回值:无。
* 说明:features、window和init_policy先由用例选择,其他夹具状态不得跨场景泄漏。
*/
static void system_open(uint32_t decision_ms, uint32_t ack_ms)
{
IEC104_SlaveConfig_t config;
IEC104_SystemCommandConfig_t command_config;
unsigned i;
memset(&fake, 0, sizeof(fake));
memset(system_stations, 0, sizeof(system_stations));
memset(&system_input, 0, sizeof(system_input));
memset(&system_reset_receipt, 0, sizeof(system_reset_receipt));
fake.now = 1000U;
system_ns = action_calls = count_calls = discard_calls = application_cleared = 0U;
action_mode = 0U; action_advance = count_advance = 0U;
send_wait_type = send_failure = ack_submit_wait = count_failure = discard_failure = 0;
handoff_override = ack_override = -9; ack_override_time = 0U;
system_slave = IEC104_Slave_Create();
CHECK(system_slave != NULL);
test_transport_config(&config);
config.protocol.link.k = system_window;
config.protocol.link.t1_ms = 600000U;
config.protocol.link.t3_ms = 600000U;
config.protocol.local_send_timeout_ms = 600000U;
CHECK(IEC104_Slave_Init(system_slave, &config, NULL) == IEC104_TCP_OK);
CHECK(IEC104_Slave_Add_Station(system_slave, &system_stations[0], 1U, &application_cleared) == IEC104_STATION_OK);
test_system_config(&command_config);
command_config.features = system_features;
command_config.init_policy = system_policy;
command_config.decision_timeout_ms = decision_ms;
command_config.reset_ack_timeout_ms = ack_ms;
system_command = IEC104_SystemCommand_Create(system_slave, &command_config);
CHECK(system_command != NULL);
sut = NULL;
for (i = 0U; i < IEC104_TCP_SERVER_CAPACITY; ++i) {
if (server_pool[i].in_use) { sut = &server_pool[i].server; break; }
}
CHECK(sut != NULL);
fake.accept_pending = 1U;
system_poll();
push(start_act, sizeof(start_act)); system_poll();
system_get_status(); CHECK(system_status.active);
}
/**
* 功能:走真实退出协议,并逐站检查Is_Reusable。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:否则清空fixture内存可能掩盖引用泄漏。
* 已删除站也在此检查,注册站则先Remove再检查,不能把“仍注册”误判成引用未释放。
*/
static void system_close(void)
{
unsigned i;
IEC104_SystemCommand_Cancel(system_command);
CHECK(IEC104_Slave_Close(system_slave, NULL) == IEC104_TCP_OK);
system_drain();
CHECK(IEC104_SystemCommand_Destroy(system_command));
for (i = 0U; i < 3U; ++i) {
if (IEC104_Station_Is_Registered(&system_stations[i])) {
CHECK(IEC104_Slave_Remove_Station(system_slave, &system_stations[i]) == IEC104_STATION_OK);
}
CHECK(IEC104_Station_Is_Reusable(&system_stations[i]));
}
CHECK(IEC104_Slave_Destroy(system_slave, NULL) == IEC104_TCP_OK);
system_features = 15U; system_window = 32U; system_policy = IEC104_SYSTEM_COMMAND_INIT_ONCE;
}
/**
* 功能:[COMMON/WIRE] APCI和期望ASDU手写,不借待测模块生成预期。
* 输入参数:bytes——报文字节缓冲区(只读);length——字节长度。
* 输出参数:无。
* 返回值:无。
* 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。
*/
static void system_queue(const uint8_t *bytes, size_t length)
{
uint8_t frame[255] = {0x68U};
CHECK(length <= 249U);
frame[1] = (uint8_t)(length + 4U);
frame[2] = (uint8_t)(system_ns << 1); frame[3] = (uint8_t)(system_ns >> 7);
/* 不额外确认新帧,但不能把已累计确认的位置退回0;READY后仍可继续发测试请求。 */
frame[4] = (uint8_t)(sut->connection.link_state.va << 1);
frame[5] = (uint8_t)(sut->connection.link_state.va >> 7);
++system_ns;
memcpy(frame + 6U, bytes, length);
push(frame, length + 6U);
}
/**
* 功能:仅完成接收及事件分派。
* 输入参数:bytes——报文字节缓冲区(只读);length——字节长度。
* 输出参数:无。
* 返回值:无。
* 说明:不自动Execute_Next或ACK,保留业务动作的显式控制点。
*/
static void system_request(const uint8_t *bytes, size_t length)
{
system_queue(bytes, length);
system_poll();
}
/**
* 功能:只收集输出里的I帧ASDU。
* 输入参数:frames——按线上顺序排列的 ASDU 视图数组;lengths——各 ASDU 的长度数组。
* 输出参数:frames——按线上顺序排列的 ASDU 视图数组;lengths——各 ASDU 的长度数组。
* 返回值:本次收集或统计到的有效业务帧数量。
* 说明:过滤U/S帧及测试占位Type200,便于独立比较业务FIFO。
* 返回指针借用fake.output,不能跨fixture重建或输出缓冲复用保存。
*/
static unsigned system_collect(const uint8_t **frames, size_t *lengths)
{
size_t offset = 0U;
unsigned count = 0U;
while (offset < fake.sent_bytes) {
const uint8_t *frame = fake.output + offset;
size_t length = (size_t)frame[1] + 2U;
CHECK(length >= 6U && offset + length <= fake.sent_bytes);
if ((frame[2] & 1U) == 0U && frame[6] != 200U) {
CHECK(count < 64U);
frames[count] = frame + 6U; lengths[count++] = length - 6U;
}
offset += length;
}
return count;
}
/**
* 功能:返回已写出的业务ASDU数。
* 输入参数:无。
* 输出参数:无。
* 返回值:本次收集或统计到的有效业务帧数量。
* 说明:既不统计U/S控制帧,也不把排入HIGH等同于已经发出。
*/
static unsigned system_frame_count(void)
{
const uint8_t *frames[64]; size_t lengths[64];
return system_collect(frames, lengths);
}
/**
* 功能:按业务帧序号逐字节比较独立预期,覆盖COT、P/N、CA、OA及对象回显。
* 输入参数:index——待访问或核对的条目下标;expected——期望的结果或数量(只读);length——字节长度。
* 输出参数:无。
* 返回值:无。
* 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。
*/
static void system_expect(unsigned index, const uint8_t *expected, size_t length)
{
const uint8_t *frames[64]; size_t lengths[64];
unsigned count = system_collect(frames, lengths);
if (count <= index) {
fprintf(stderr, "SystemCommand missing frame group=%u expected=%u actual=%u actions=%u\n",
system_groups, index, count, action_calls);
}
CHECK(count > index);
CHECK(lengths[index] == length);
CHECK(memcmp(frames[index], expected, length) == 0);
}
/**
* 功能:主站累计确认当前已分配的发送序号。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:调用位置由用例控制,不能混进flush自动放行复位。
*/
static void system_ack_all(void)
{
if (sut->connection.link_state.vs != sut->connection.link_state.va) {
push_ack(sut->connection.link_state.vs); system_poll();
}
}
/**
* 功能:[COMMON/ACTION] 检查原站身份并统计唯一调用次数。
* 输入参数:context——业务回调的测试上下文;request——当前业务请求(只读)。
* 输出参数:无。
* 返回值:动作回调的接受或拒绝决定。
* 说明:QRP2的应用清除用独立计数代表。
* fake.now变化模拟短时同步动作的耗时,故不产生Slave通知,也不违反“不推进Slave”的契约。
*/
static IEC104_SystemCommandDecision_t system_action(void *context,
const IEC104_SystemCommandResetRequest_t *request)
{
CHECK(context == &application_cleared);
CHECK(request->station_id != 0U && request->common_address == 1U);
CHECK(IEC104_Slave_Get_Station_By_Id(system_slave, request->station_id) == &system_stations[0]);
++action_calls;
if (action_mode == 3U) {
IEC104_SystemCommandStatus_t status;
IEC104_SystemCommandResetRequest_t output;
CHECK(IEC104_SystemCommand_Get_Status(system_command, &status));
CHECK(IEC104_SystemCommand_Handle_Event(system_command, &system_input) == IEC104_SYSTEM_COMMAND_EVENT_ERROR);
CHECK(!IEC104_SystemCommand_Process(system_command));
CHECK(IEC104_SystemCommand_Execute_Next(system_command, system_action, context) == IEC104_SYSTEM_COMMAND_EXECUTE_ERROR);
CHECK(!IEC104_SystemCommand_Set_Initialization(system_command, 0U));
CHECK(!IEC104_SystemCommand_Take_Reset(system_command, &output));
CHECK(!IEC104_SystemCommand_Destroy(system_command));
IEC104_SystemCommand_Cancel(system_command);
CHECK(IEC104_SystemCommand_Get_Status(system_command, &status) && status.pending_tasks == 1U);
}
fake.now += action_advance;
if (action_mode == 1U) { return IEC104_SYSTEM_COMMAND_DECISION_REJECT; }
if (action_mode == 2U) { return (IEC104_SystemCommandDecision_t)9; }
if (request->qualifier == 2U) { ++application_cleared; }
return IEC104_SYSTEM_COMMAND_DECISION_ACCEPT;
}
/**
* 功能:显式执行一个待决定请求。
* 输入参数:无。
* 输出参数:无。
* 返回值:单步执行结果,区分已执行、无任务、等待及错误。
* 说明:用例通过返回值及action_calls区分无任务、让出和动作完成。
*/
static IEC104_SystemCommandExecuteResult_t system_execute(void)
{
return IEC104_SystemCommand_Execute_Next(system_command, system_action, &application_cleared);
}
/* [105/HELPERS] 复位专项辅助:建立真实ACK等待、检查观察槽与原站引用、比较原请求身份。
* 辅助只推进到显式约定的边界;ACK、STOP、断线及Take仍由每个用例控制。 */
/**
* 功能:直接数非空观察票据,检查Take/取消释放观察槽。
* 输入参数:无。
* 输出参数:无。
* 返回值:当前非空 ACK 观察票据的数量。
* 说明:单看reset_ready不足以发现资源泄漏。
*/
static unsigned system_ack_watch_count(void)
{
unsigned count = 0U;
size_t i;
for (i = 0U; i < IEC104_TCP_ACK_WATCH_CAPACITY; ++i) {
if (sut->ack_watches[i].ticket != 0U) { ++count; }
}
return count;
}
/**
* 功能:从真实正向ACT_CON建立等待ACK的请求。
* 输入参数:ack_ms——ACK 等待期限(毫秒);identity——请求所属的 Slave、实例及连接代次身份。
* 输出参数:identity——建立连接后取得的当前事件身份。
* 返回值:无。
* 说明:不自动ACK,不推进到READY。
*/
static void system_prepare_reset(uint32_t ack_ms, IEC104_SlaveEventIdentity_t *identity)
{
system_open(100U, ack_ms);
system_request(system_reset_request, sizeof(system_reset_request));
CHECK(IEC104_Slave_Get_Event_Identity(system_slave, &system_input, identity));
CHECK(system_execute() == IEC104_SYSTEM_COMMAND_EXECUTE_OK);
system_flush();
CHECK(system_frame_count() == 1U && action_calls == 1U);
system_expect(0U, system_reset_confirmation, sizeof(system_reset_confirmation));
CHECK(system_status.ack_pending && !system_status.reset_ready && system_status.pending_tasks == 0U);
CHECK(system_ack_watch_count() == 1U);
CHECK(IEC104_Slave_Get_Ack_State(system_slave, &system_reset_receipt, NULL) == IEC104_SLAVE_ACK_SENT);
CHECK(IEC104_Slave_Get_Active_Ack_State(system_slave, &system_reset_receipt, NULL) == IEC104_SLAVE_ACK_SENT);
}
/**
* 功能:交出纯值后立即验证两类模块资源均释放。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:Remove/Add不改变已交出的原请求身份。
*/
static void system_expect_reset_released(void)
{
CHECK(system_ack_watch_count() == 0U);
CHECK(IEC104_Slave_Get_Ack_State(system_slave, &system_reset_receipt, NULL) == IEC104_SLAVE_ACK_ERROR);
CHECK(IEC104_Slave_Get_Active_Ack_State(system_slave, &system_reset_receipt, NULL) == IEC104_SLAVE_ACK_ERROR);
CHECK(IEC104_Slave_Remove_Station(system_slave, &system_stations[0]) == IEC104_STATION_OK);
CHECK(IEC104_Station_Is_Reusable(&system_stations[0]));
CHECK(IEC104_Slave_Add_Station(system_slave, &system_stations[0], 1U, &application_cleared) == IEC104_STATION_OK);
}
/**
* 功能:检查交出的是原请求纯值,包括旧代次、原站注册编号和OA/QRP。
* 输入参数:request——当前业务请求(只读);identity——请求所属的 Slave、实例及连接代次身份(只读);station_id——站点实例标识。
* 输出参数:无。
* 返回值:无。
* 说明:重连不能重绑身份。
*/
static void system_expect_reset_identity(const IEC104_SystemCommandResetRequest_t *request,
const IEC104_SlaveEventIdentity_t *identity, uint64_t station_id)
{
CHECK(request->identity.slave == identity->slave && request->identity.instance_id == identity->instance_id);
CHECK(request->identity.generation == identity->generation && request->receive_serial != 0U);
CHECK(request->station_id == station_id && request->common_address == 1U);
CHECK(request->originator_address == 8U && request->qualifier == 1U);
}
/**
* 功能:[105/CLEAR_HELPER] 直接向真实NORMAL放手写的Type1/30,独立于应用清除计数。
* 输入参数:ca——公共地址;timed——是否构造带时标类型。
* 输出参数:无。
* 返回值:无。
* 说明:CA与有无时标由调用方选择,用于区分QRP2的目标站、事件形态和应用/库两层清除。
*/
static void system_enqueue(uint16_t ca, bool timed)
{
uint8_t bytes[17] = {30U,1U,3U,0U,1U,0U,1U,0U,0U,1U,0U,0U,0U,0U,1U,1U,24U};
IEC60870_Asdu_t asdu;
bytes[0] = timed ? 30U : 1U; bytes[4] = (uint8_t)ca; bytes[5] = (uint8_t)(ca >> 8);
CHECK(IEC60870_Asdu_Create_From_Buffer(&asdu, IEC104_Slave_Get_Application_Layer_Parameters(system_slave),
bytes, timed ? 17U : 10U) == IEC60870_ASDU_OK);
CHECK(IEC104_Slave_Enqueue_Event(system_slave, &asdu) == IEC104_TCP_SUBMIT_OK);
}
/**
* 功能:验证以下场景与约束:[104/VALIDATION] 两个图样字节分别校验。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:错误回显不把图样修复成AA 55。
* 混合错误保证COT/CA/IOA优先于图样;OA、双字节CA及TEST均由独立期望帧检查。
*/
static void test_system_104_validation(void)
{
unsigned test, mode;
for (test = 0U; test < 2U; ++test) {
for (mode = 0U; mode < 15U; ++mode) {
uint8_t request[16] = {0U}, expected[11];
IEC104_SystemCommandResetRequest_t reset;
size_t length = sizeof(system_untimed_test_request);
uint8_t cause = 7U;
bool valid = mode == 0U || mode == 14U;
bool silent = mode >= 11U && mode <= 13U;
memcpy(request, system_untimed_test_request, sizeof(system_untimed_test_request));
if (test != 0U) { request[2] |= 0x80U; }
switch (mode) {
case 0U: break;
case 1U: request[9] ^= 1U; break;
case 2U: request[10] ^= 1U; break;
case 3U: request[9] = 0x55U; request[10] = 0xaaU; break;
case 4U:
request[2] = (uint8_t)(5U | (test != 0U ? 0x80U : 0U));
request[4] = 99U; request[6] = 1U; request[9] = 0U; cause = 45U;
break;
case 5U: request[4] = 99U; request[6] = 1U; request[9] = 0U; cause = 46U; break;
case 6U: request[4] = request[5] = 255U; cause = 46U; break;
case 7U: request[6] = 1U; request[9] = 0U; cause = 47U; break;
case 8U: request[1] = 0x81U; break;
case 9U: request[2] |= 0x40U; break;
case 10U: request[11] = 0xeeU; length = 12U; break;
case 11U:
request[1] = 2U; request[14] = 0xaaU; request[15] = 0x55U; length = 16U;
break;
case 12U: request[1] = 0U; length = 6U; break;
case 13U: length = 10U; break;
default: request[4] = 0x34U; request[5] = 0x12U; break;
}
memcpy(expected, request, sizeof(expected));
expected[1] = 1U;
expected[2] = (uint8_t)((request[2] & 0x80U) | cause | (valid ? 0U : 0x40U));
system_open(100U, 100U);
if (mode == 14U) {
CHECK(IEC104_Slave_Add_Station(system_slave, &system_stations[1], 0x1234U, NULL) == IEC104_STATION_OK);
}
system_request(request, length); system_flush();
CHECK(system_frame_count() == (silent ? 0U : 1U));
if (!silent) { system_expect(0U, expected, sizeof(expected)); }
CHECK(system_status.test_accepted == (valid ? 1U : 0U));
CHECK(system_status.test_answered == (valid ? 1U : 0U));
/* 零/多对象进入业务拒绝;模式13载荷截短先被Receiver拦截,不计业务rejected。 */
CHECK(system_status.rejected == (!valid && mode != 13U ? 1U : 0U));
CHECK(system_status.reset_accepted == 0U && !system_status.reset_ready && !system_status.ack_pending);
CHECK(system_execute() == IEC104_SYSTEM_COMMAND_EXECUTE_EMPTY && action_calls == 0U);
CHECK(application_cleared == 0U && count_calls == 0U && discard_calls == 0U);
CHECK(system_ack_watch_count() == 0U && !IEC104_SystemCommand_Take_Reset(system_command, &reset));
system_close(); ++system_groups;
}
}
}
/**
* 功能:验证以下场景与约束:[TEST/FEATURE] 单独启用测试服务即同时接入104/107。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:关闭后均交给调用方的未知类型兜底。
*/
static void test_system_test_feature(void)
{
unsigned enabled, timed;
for (enabled = 0U; enabled < 2U; ++enabled) {
for (timed = 0U; timed < 2U; ++timed) {
const uint8_t *request = timed ? system_test_request : system_untimed_test_request;
size_t length = timed ? sizeof(system_test_request) : sizeof(system_untimed_test_request);
system_features = enabled ? IEC104_SYSTEM_COMMAND_FEATURE_TEST_COMMAND : IEC104_SYSTEM_COMMAND_FEATURE_INIT_END;
system_open(100U, 100U);
system_request(request, length); system_flush();
CHECK(system_handled == (enabled ? IEC104_SYSTEM_COMMAND_EVENT_HANDLED : IEC104_SYSTEM_COMMAND_EVENT_IGNORED));
CHECK(system_frame_count() == enabled && system_status.test_answered == enabled);
CHECK(action_calls == 0U && system_status.reset_accepted == 0U && system_ack_watch_count() == 0U);
system_close(); ++system_groups;
}
}
}
/**
* 功能:验证以下场景与约束:[104/FLOW] 正/负确认均保留原槽等待,反复推进只能交接一次,不产生复位动作。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。
*/
static void test_system_104_wait(void)
{
unsigned negative;
for (negative = 0U; negative < 2U; ++negative) {
uint8_t request[11], expected[11];
memcpy(request, system_untimed_test_request, sizeof(request));
if (negative != 0U) { request[10] = 0U; }
memcpy(expected, request, sizeof(expected)); expected[2] = negative ? 0x47U : 7U;
system_open(100U, 100U); send_wait_type = 104;
system_request(request, sizeof(request)); system_flush();
CHECK(system_status.pending_tasks == 1U && system_status.send_waiting && !system_status.need_process);
CHECK(system_frame_count() == 0U && system_status.test_answered == 0U);
CHECK(system_execute() == IEC104_SYSTEM_COMMAND_EXECUTE_EMPTY && action_calls == 0U);
send_wait_type = 0; system_flush(); system_flush();
CHECK(system_frame_count() == 1U && system_status.pending_tasks == 0U);
CHECK(system_status.test_answered == (negative ? 0U : 1U));
CHECK(system_status.negative_submitted == negative && system_ack_watch_count() == 0U);
system_expect(0U, expected, sizeof(expected));
system_close(); ++system_groups;
}
}
/**
* 功能:验证以下场景与约束:104的WAIT不能被105动作或107回复越过。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:105决定完成后按104/105/107顺序写出。
*/
static void test_system_104_mixed_fifo(void)
{
uint8_t reset[10], expected_reset[10], expected_104[11], expected_107[18];
if (IEC104_SYSTEM_COMMAND_TASK_CAPACITY < 3U) { return; }
/* 选QRP2消除ACK授权等待的影响,只检查104堵塞时后续动作与回复能否越过FIFO队首。 */
memcpy(reset, system_reset_request, sizeof(reset)); reset[9] = 2U;
memcpy(expected_reset, reset, sizeof(expected_reset)); expected_reset[2] = 7U;
memcpy(expected_104, system_untimed_test_request, sizeof(expected_104)); expected_104[2] = 7U;
memcpy(expected_107, system_test_request, sizeof(expected_107)); expected_107[2] = 7U;
system_open(1000U, 1000U); send_wait_type = 104;
system_queue(system_untimed_test_request, sizeof(system_untimed_test_request));
system_queue(reset, sizeof(reset)); system_queue(system_test_request, sizeof(system_test_request));
system_poll(); system_flush();
CHECK(system_status.pending_tasks == 3U && system_status.send_waiting && system_frame_count() == 0U);
CHECK(system_execute() == IEC104_SYSTEM_COMMAND_EXECUTE_EMPTY && action_calls == 0U);
send_wait_type = 0; system_flush();
CHECK(system_frame_count() == 1U && system_status.decide_pending && system_status.pending_tasks == 2U);
system_expect(0U, expected_104, sizeof(expected_104));
CHECK(system_execute() == IEC104_SYSTEM_COMMAND_EXECUTE_OK); system_flush();
CHECK(system_frame_count() == 3U && system_status.pending_tasks == 0U);
system_expect(1U, expected_reset, sizeof(expected_reset));
system_expect(2U, expected_107, sizeof(expected_107));
CHECK(system_status.test_accepted == 2U && system_status.test_answered == 2U);
CHECK(action_calls == 1U && application_cleared == 1U && system_ack_watch_count() == 0U);
system_close(); ++system_groups;
}
/**
* 功能:验证以下场景与约束:相同的104请求各占一个槽、各回一次确认。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:满槽丢新后既不合并也不补发。
*/
static void test_system_104_capacity(void)
{
uint8_t expected[11];
unsigned i;
memcpy(expected, system_untimed_test_request, sizeof(expected)); expected[2] = 7U;
system_open(100U, 100U); send_wait_type = 104;
for (i = 0U; i <= IEC104_SYSTEM_COMMAND_TASK_CAPACITY; ++i) {
system_queue(system_untimed_test_request, sizeof(system_untimed_test_request));
}
system_poll(); system_flush();
CHECK(system_status.pending_tasks == IEC104_SYSTEM_COMMAND_TASK_CAPACITY);
CHECK(system_status.overloads == 1U && system_status.dropped_requests == 1U && system_frame_count() == 0U);
send_wait_type = 0; system_flush();
CHECK(system_status.test_accepted == IEC104_SYSTEM_COMMAND_TASK_CAPACITY);
CHECK(system_status.test_answered == IEC104_SYSTEM_COMMAND_TASK_CAPACITY);
CHECK(system_frame_count() == IEC104_SYSTEM_COMMAND_TASK_CAPACITY && system_status.pending_tasks == 0U);
for (i = 0U; i < IEC104_SYSTEM_COMMAND_TASK_CAPACITY; ++i) { system_expect(i, expected, sizeof(expected)); }
CHECK(action_calls == 0U && system_ack_watch_count() == 0U);
system_close(); ++system_groups;
}
/**
* 功能:验证以下场景与约束:STOP/断线清理104的WAIT及站引用。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:恢复或换代后只允许新请求产生确认。
*/
static void test_system_104_session(void)
{
unsigned disconnected;
for (disconnected = 0U; disconnected < 2U; ++disconnected) {
uint8_t expected[11];
uint64_t generation;
memcpy(expected, system_untimed_test_request, sizeof(expected)); expected[2] = 7U;
system_open(100U, 100U); send_wait_type = 104;
system_request(system_untimed_test_request, sizeof(system_untimed_test_request)); system_flush();
CHECK(system_status.pending_tasks == 1U && system_status.send_waiting);
generation = system_status.generation;
if (disconnected) { fake.recv_eof = 1U; } else { push(stop_act, sizeof(stop_act)); }
system_poll(); fake.recv_eof = 0U; system_get_status();
CHECK(system_status.cancelled == 1U && system_status.pending_tasks == 0U && !system_status.active);
/* 原站移除后可复用,证明取消也归还了104持有的引用,而非仅把pending计数清零。 */
CHECK(IEC104_Slave_Remove_Station(system_slave, &system_stations[0]) == IEC104_STATION_OK);
CHECK(IEC104_Station_Is_Reusable(&system_stations[0]));
CHECK(IEC104_Slave_Add_Station(system_slave, &system_stations[0], 1U, &application_cleared) == IEC104_STATION_OK);
send_wait_type = 0;
if (disconnected) { fake.accept_pending = 1U; system_ns = 0U; system_poll(); }
push(start_act, sizeof(start_act)); system_poll(); system_flush();
CHECK(system_status.active && (system_status.generation != generation) == (disconnected != 0U));
CHECK(system_frame_count() == 0U);
system_request(system_untimed_test_request, sizeof(system_untimed_test_request)); system_flush();
CHECK(system_frame_count() == 1U && system_status.test_answered == 1U && action_calls == 0U);
system_expect(0U, expected, sizeof(expected));
system_close(); ++system_groups;
}
}
/**
* 功能:验证以下场景与约束:[107/VALIDATION] 混合错误验证45/46/47先于负ACT_CON。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:完整对象不足只静默丢弃。
*/
static void test_system_107_validation(void)
{
unsigned mode;
for (mode = 0U; mode < 13U; ++mode) {
uint8_t request[30] = {0U}, expected[18];
size_t length = 18U;
unsigned cause = 7U;
bool silent = false;
memcpy(request, system_test_request, 18U); request[18] = 0xeeU;
switch (mode) {
case 0: break;
case 1: request[2] |= 0x80U; request[13] |= 0x80U; break; /* TEST与时标IV合法。 */
case 2: request[2] = 5U; request[4] = 99U; request[6] = 1U; cause = 45U; break;
case 3: request[4] = 99U; request[6] = 1U; cause = 46U; break;
case 4: request[4] = request[5] = 255U; cause = 46U; break;
case 5: request[6] = 1U; cause = 47U; break;
case 6: request[1] = 0x81U; break;
case 7: request[2] |= 0x40U; break;
case 8: length = 19U; break;
case 9: request[16] = 0U; break;
case 10: request[1] = 2U; length = 30U; silent = true; break;
case 11: request[1] = 0U; length = 6U; silent = true; break;
default: length = 17U; silent = true; break; /* Receiver先拒绝截短对象,不交业务。 */
}
memcpy(expected, request, sizeof(expected));
expected[1] = 1U;
expected[2] = (uint8_t)((request[2] & 0x80U) | cause | (mode >= 2U ? 0x40U : 0U));
system_open(100U, 100U);
system_request(request, length); system_flush();
CHECK(action_calls == 0U);
CHECK(system_frame_count() == (silent ? 0U : 1U));
if (!silent) { system_expect(0U, expected, sizeof(expected)); }
if (system_status.rejected != (mode >= 2U && mode != 12U ? 1U : 0U)) {
fprintf(stderr, "107 validation mode=%u rejected=%lu handled=%d\n", mode,
system_status.rejected, (int)system_handled);
}
CHECK(system_status.rejected == (mode >= 2U && mode != 12U ? 1U : 0U));
CHECK(system_status.test_answered == (mode < 2U ? 1U : 0U));
system_close(); ++system_groups;
}
}
/**
* 功能:验证以下场景与约束:[107/CP56] 测试命令按日历接收错误星期与GEN,响应保留完整原始时标。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:IV是107可回显的测试内容,不照搬103/遥控的执行拒绝规则;真正保留位和非法日期仍否定。
* 全部场景同时覆盖T=0/1,均不得调用复位动作或建立复位授权。
*/
static void test_system_107_auxiliary_fields(void)
{
unsigned variant, test, mode;
for (variant = 0U; variant < 4U; ++variant) {
for (test = 0U; test < 2U; ++test) {
for (mode = 0U; mode < 7U; ++mode) {
uint8_t request[sizeof(system_test_request)], expected[sizeof(system_test_request)];
memcpy(request, system_test_request, sizeof(request));
if ((variant & 1U) != 0U) { request[15] |= 0x40U; } /* 2024-01-01周一,故意填写周二。 */
if ((variant & 2U) != 0U) { request[13] |= 0x40U; }
if (test != 0U) { request[2] |= 0x80U; }
switch (mode) {
case 0U: break;
case 1U: request[13] |= 0x80U; break;
case 2U:
request[15] = (uint8_t)((request[15] & 0xe0U) | 30U); request[16] = 2U;
break;
case 3U: request[14] |= 0x20U; break;
case 4U: request[14] |= 0x40U; break;
case 5U: request[16] |= 0x80U; break;
default: request[17] |= 0x80U; break;
}
memcpy(expected, request, sizeof(expected));
expected[2] = (uint8_t)(7U | (test != 0U ? 0x80U : 0U) | (mode >= 2U ? 0x40U : 0U));
system_open(100U, 100U);
system_request(request, sizeof(request)); system_flush();
CHECK(system_frame_count() == 1U && action_calls == 0U);
system_expect(0U, expected, sizeof(expected));
CHECK(system_status.test_answered == (mode < 2U ? 1U : 0U));
CHECK(system_status.rejected == (mode >= 2U ? 1U : 0U));
CHECK(!system_status.ack_pending && !system_status.reset_ready);
system_close(); ++system_groups;
}
}
}
}
/**
* 功能:验证以下场景与约束:[70/ROUNDS] 主动登记、逐站帧、ONCE/EVERY_START及无站表的启动许可。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。
*/
static void test_system_init_rounds(void)
{
uint8_t expected[10] = {70U,1U,4U,0U,1U,0U,0U,0U,0U,0U};
IEC104_TcpServerStatus_t service;
uint64_t first_activation;
system_open(100U, 100U); system_flush(); CHECK(system_frame_count() == 0U);
CHECK(!IEC104_SystemCommand_Set_Initialization(system_command, 3U));
CHECK(!IEC104_SystemCommand_Set_Initialization(system_command, 159U));
CHECK(IEC104_Slave_Add_Station(system_slave, &system_stations[1], 2U, NULL) == IEC104_STATION_OK);
CHECK(IEC104_SystemCommand_Set_Initialization(system_command, 0U));
system_flush(); CHECK(system_status.init_rounds == 1U && system_status.init_frames == 2U);
CHECK(IEC104_Slave_Get_Status(system_slave, &service, NULL) == IEC104_TCP_OK);
first_activation = service.activation_id;
CHECK(first_activation != 0U && system_status.init_completed_activation_id == first_activation);
system_expect(0U, expected, sizeof(expected)); expected[4] = 2U; system_expect(1U, expected, sizeof(expected));
push(stop_act, sizeof(stop_act)); system_poll(); push(start_act, sizeof(start_act)); system_poll();
system_flush(); CHECK(system_status.init_rounds == 1U);
CHECK(IEC104_Slave_Get_Status(system_slave, &service, NULL) == IEC104_TCP_OK);
CHECK(service.activation_id != first_activation && system_status.init_completed_activation_id == first_activation);
CHECK(IEC104_SystemCommand_Set_Initialization(system_command, 0x82U));
system_flush(); expected[4] = 1U; expected[9] = 0x82U; system_expect(2U, expected, sizeof(expected));
CHECK(system_status.init_completed_activation_id == service.activation_id);
system_close(); ++system_groups;
system_policy = IEC104_SYSTEM_COMMAND_INIT_EVERY_START;
system_open(100U, 100U); CHECK(IEC104_SystemCommand_Set_Initialization(system_command, 1U));
system_flush(); CHECK(system_status.init_rounds == 1U);
push(start_act, sizeof(start_act)); system_poll(); system_flush(); CHECK(system_status.init_rounds == 1U);
push(stop_act, sizeof(stop_act)); system_poll(); push(start_act, sizeof(start_act)); system_poll();
system_flush(); CHECK(system_status.init_rounds == 2U); system_close(); ++system_groups;
system_open(100U, 100U);
CHECK(IEC104_Slave_Remove_Station(system_slave, &system_stations[0]) == IEC104_STATION_OK);
CHECK(IEC104_SystemCommand_Set_Initialization(system_command, 0U)); system_flush();
CHECK(system_status.init_empty_rounds == 1U && system_status.init_armed && !system_status.init_start_allowed);
CHECK(system_status.init_completed_activation_id == 0U);
CHECK(!system_status.need_process); system_flush(); CHECK(system_status.init_empty_rounds == 1U);
CHECK(IEC104_Slave_Add_Station(system_slave, &system_stations[0], 1U, NULL) == IEC104_STATION_OK);
system_flush(); CHECK(system_frame_count() == 0U);
CHECK(IEC104_SystemCommand_Set_Initialization(system_command, 2U)); system_flush();
CHECK(system_status.init_rounds == 1U); system_close(); ++system_groups;
}
/**
* 功能:验证以下场景与约束:[70/TRANSITIONS] 空轮与中止采用最新pending。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:一个来源成功不清另一来源WAIT。
*/
static void test_system_init_pending_and_wait(void)
{
uint8_t expected[10] = {70U,1U,4U,0U,1U,0U,0U,0U,0U,2U};
system_open(100U, 100U); send_wait_type = 70;
CHECK(IEC104_SystemCommand_Set_Initialization(system_command, 0U));
CHECK(IEC104_SystemCommand_Process(system_command));
CHECK(IEC104_SystemCommand_Set_Initialization(system_command, 1U));
CHECK(IEC104_SystemCommand_Set_Initialization(system_command, 2U));
CHECK(IEC104_Slave_Remove_Station(system_slave, &system_stations[0]) == IEC104_STATION_OK);
system_flush(); CHECK(system_status.init_empty_rounds == 1U && !system_status.init_start_allowed);
CHECK(IEC104_Station_Is_Reusable(&system_stations[0]));
CHECK(IEC104_Slave_Add_Station(system_slave, &system_stations[0], 1U, NULL) == IEC104_STATION_OK);
send_wait_type = 0;
push(stop_act, sizeof(stop_act)); system_poll(); push(start_act, sizeof(start_act)); system_poll();
system_flush(); system_expect(0U, expected, sizeof(expected)); system_close(); ++system_groups;
system_open(100U, 100U); send_wait_type = 70;
CHECK(IEC104_SystemCommand_Set_Initialization(system_command, 0U));
CHECK(IEC104_SystemCommand_Process(system_command));
system_request(system_test_request, sizeof(system_test_request)); system_flush();
CHECK(system_status.test_answered == 1U && system_status.send_waiting && !system_status.need_process);
CHECK(IEC104_SystemCommand_Set_Initialization(system_command, 2U));
push(stop_act, sizeof(stop_act)); system_poll(); send_wait_type = 0;
push(start_act, sizeof(start_act)); system_poll(); system_flush();
system_expect(1U, expected, sizeof(expected)); system_close(); ++system_groups;
system_open(100U, 100U); handoff_override = IEC104_RESPONSE_PENDING;
CHECK(IEC104_SystemCommand_Set_Initialization(system_command, 0U)); system_flush();
CHECK(system_status.handoff_pending && !system_status.need_process);
CHECK(IEC104_SystemCommand_Set_Initialization(system_command, 2U));
IEC104_SystemCommand_Cancel(system_command); system_get_status();
CHECK(system_status.init_armed && !system_status.init_start_allowed && system_status.init_retries == 1U);
handoff_override = -9; push(stop_act, sizeof(stop_act)); system_poll();
push(start_act, sizeof(start_act)); system_poll(); system_flush();
system_expect(1U, expected, sizeof(expected)); system_close(); ++system_groups;
system_open(100U, 100U); handoff_override = IEC104_RESPONSE_PENDING;
CHECK(IEC104_SystemCommand_Set_Initialization(system_command, 0U)); system_flush();
handoff_override = IEC104_RESPONSE_HANDED;
push(stop_act, sizeof(stop_act)); system_poll(); system_get_status();
CHECK(system_status.init_rounds == 1U && system_status.init_retries == 0U);
handoff_override = -9; push(start_act, sizeof(start_act)); system_poll(); system_flush();
CHECK(system_frame_count() == 1U); system_close(); ++system_groups;
}
/**
* 功能:验证以下场景与约束:三站Type70均已提交,但k=1只让首站交接。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:完成轮次必须等待末站HANDED,且不等待末站ACK。
*/
static void test_system_init_completion_handoff(void)
{
IEC104_TcpServerStatus_t service;
uint64_t activation;
system_window = 1U;
system_open(100U, 100U);
CHECK(IEC104_Slave_Add_Station(system_slave, &system_stations[1], 2U, NULL) == IEC104_STATION_OK);
CHECK(IEC104_Slave_Add_Station(system_slave, &system_stations[2], 3U, NULL) == IEC104_STATION_OK);
CHECK(IEC104_Slave_Get_Status(system_slave, &service, NULL) == IEC104_TCP_OK);
activation = service.activation_id;
CHECK(activation != 0U && system_status.init_completed_activation_id == 0U);
CHECK(IEC104_SystemCommand_Set_Initialization(system_command, 0U));
system_flush();
CHECK(system_status.init_frames == 3U && system_status.init_rounds == 0U && system_status.handoff_pending);
CHECK(system_status.init_completed_activation_id == 0U && system_frame_count() == 1U);
push_ack(1U); system_flush();
CHECK(system_frame_count() == 2U && system_status.init_rounds == 0U && system_status.handoff_pending);
CHECK(system_status.init_completed_activation_id == 0U);
push_ack(2U); system_flush();
CHECK(system_frame_count() == 3U && system_status.init_rounds == 1U && !system_status.init_round_active);
CHECK(system_status.init_completed_activation_id == activation);
system_close(); ++system_groups;
}
/**
* 功能:验证以下场景与约束:EVERY_START区分重复START与真实新激活。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:旧完成ID仅为历史诊断,不能满足新轮次的门禁。
*/
static void test_system_init_completion_restart(void)
{
unsigned disconnected;
for (disconnected = 0U; disconnected < 2U; ++disconnected) {
IEC104_TcpServerStatus_t service;
uint64_t old_activation, new_activation;
system_policy = IEC104_SYSTEM_COMMAND_INIT_EVERY_START;
system_open(100U, 100U);
CHECK(IEC104_SystemCommand_Set_Initialization(system_command, 2U));
system_flush();
CHECK(IEC104_Slave_Get_Status(system_slave, &service, NULL) == IEC104_TCP_OK);
old_activation = service.activation_id;
CHECK(system_status.init_rounds == 1U && system_status.init_completed_activation_id == old_activation);
push(start_act, sizeof(start_act)); system_poll(); system_flush();
CHECK(IEC104_Slave_Get_Status(system_slave, &service, NULL) == IEC104_TCP_OK);
CHECK(service.activation_id == old_activation && system_status.init_rounds == 1U);
if (disconnected) { fake.recv_eof = 1U; }
else { push(stop_act, sizeof(stop_act)); }
system_poll(); fake.recv_eof = 0U;
if (disconnected) { fake.accept_pending = 1U; system_ns = 0U; system_poll(); }
push(start_act, sizeof(start_act)); system_poll();
CHECK(IEC104_Slave_Get_Status(system_slave, &service, NULL) == IEC104_TCP_OK);
new_activation = service.activation_id;
system_get_status();
CHECK(new_activation != old_activation && system_status.init_armed);
CHECK(system_status.init_completed_activation_id == old_activation);
handoff_override = IEC104_RESPONSE_PENDING;
system_flush();
CHECK(system_status.init_rounds == 1U && system_status.init_frames == 2U && system_status.handoff_pending);
CHECK(system_status.init_completed_activation_id == old_activation);
handoff_override = -9; system_flush();
CHECK(system_status.init_rounds == 2U && system_status.init_completed_activation_id == new_activation);
CHECK(!system_status.init_round_active);
system_close(); ++system_groups;
}
}
/**
* 功能:验证以下场景与约束:[105/VALIDATION] 合法TEST肯定模拟、保留QRP否定,二者均禁止动作。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:关闭整个类型时允许44兜底。
*/
static void test_system_105_validation(void)
{
unsigned mode;
for (mode = 0U; mode < 7U; ++mode) {
uint8_t request[10], expected[10];
memcpy(request, system_reset_request, sizeof(request));
if (mode == 0U) { request[2] |= 0x80U; }
else if (mode == 1U) { request[9] = 0U; }
else if (mode == 2U) { request[9] = 3U; }
else if (mode == 3U) { request[9] = 128U; }
else if (mode == 4U) { request[9] = 255U; }
else if (mode == 5U) { system_features = 11U; }
else { request[4] = request[5] = 255U; request[2] |= 0x80U; }
memcpy(expected, request, sizeof(expected));
expected[2] = (uint8_t)((request[2] & 0x80U) | (mode == 0U || mode == 6U ? 7U : 0x47U));
if (mode == 6U) { expected[4] = 1U; expected[5] = 0U; }
system_open(100U, 100U); system_request(request, sizeof(request));
CHECK(system_execute() == IEC104_SYSTEM_COMMAND_EXECUTE_EMPTY);
system_flush(); system_expect(0U, expected, sizeof(expected));
CHECK(action_calls == 0U && application_cleared == 0U && discard_calls == 0U);
system_close(); ++system_groups;
}
system_features = IEC104_SYSTEM_COMMAND_FEATURE_INIT_END;
system_open(100U, 100U);
system_request(system_reset_request, sizeof(system_reset_request));
CHECK(system_handled == IEC104_SYSTEM_COMMAND_EVENT_IGNORED);
system_request(system_test_request, sizeof(system_test_request));
CHECK(system_handled == IEC104_SYSTEM_COMMAND_EVENT_IGNORED);
system_flush(); CHECK(system_frame_count() == 0U); system_close(); ++system_groups;
}
/**
* 功能:验证以下场景与约束:[105/DECISION] 拒绝/非法枚举无库动作。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:重入受保护;回调开始后不再追认决定超时。
*/
static void test_system_decisions(void)
{
unsigned mode;
for (mode = 1U; mode <= 3U; ++mode) {
uint8_t expected[10]; memcpy(expected, system_reset_request, sizeof(expected));
expected[2] = mode == 3U ? 7U : 0x47U;
system_open(10U, 100U); action_mode = mode;
system_request(system_reset_request, sizeof(system_reset_request));
CHECK(system_execute() == IEC104_SYSTEM_COMMAND_EXECUTE_OK); system_flush();
CHECK(action_calls == 1U); system_expect(0U, expected, sizeof(expected));
if (mode == 2U) { CHECK(system_status.invalid_decisions == 1U); }
system_close(); ++system_groups;
}
system_open(10U, 100U); action_advance = 11U;
system_request(system_reset_request, sizeof(system_reset_request));
CHECK(system_execute() == IEC104_SYSTEM_COMMAND_EXECUTE_OK); system_flush();
CHECK(action_calls == 1U && system_status.timeouts == 0U && system_status.ack_pending);
system_close(); ++system_groups;
for (mode = 0U; mode < 3U; ++mode) {
system_open(mode == 2U ? 0U : 10U, 100U);
system_request(system_reset_request, sizeof(system_reset_request));
fake.now = mode == 0U ? 1010U : 999U;
CHECK(system_execute() == IEC104_SYSTEM_COMMAND_EXECUTE_OK);
/* 只让业务看到倒退,不把违反Net单调契约的采样再送入链路状态机。 */
if (fake.now < 1000U) { fake.now = 1000U; }
system_flush();
CHECK(action_calls == (mode == 2U ? 1U : 0U));
CHECK(system_status.timeouts == (mode == 2U ? 0U : 1U));
system_close(); ++system_groups;
}
if (IEC104_SYSTEM_COMMAND_TASK_CAPACITY > 1U) {
system_open(10U, 100U); send_wait_type = 107;
system_queue(system_test_request, sizeof(system_test_request));
system_queue(system_reset_request, sizeof(system_reset_request)); system_poll();
CHECK(IEC104_SystemCommand_Process(system_command)); fake.now += 10U;
CHECK(IEC104_SystemCommand_Process(system_command)); system_get_status();
CHECK(system_status.timeouts == 1U && !system_status.timer_active && !system_status.need_process);
CHECK(system_execute() == IEC104_SYSTEM_COMMAND_EXECUTE_EMPTY && action_calls == 0U);
send_wait_type = 0; system_flush(); CHECK(system_frame_count() == 2U);
system_close(); ++system_groups;
}
}
/**
* 功能:验证以下场景与约束:[105/ACK] 真实累计ACK验证协议接受时刻。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:业务处理晚于截止仍必须接受按时ACK。
*/
static void test_system_ack_deadlines(void)
{
unsigned mode;
for (mode = 0U; mode < 5U; ++mode) {
IEC104_SystemCommandResetRequest_t request, unchanged;
system_open(100U, mode == 4U ? 0U : 30000U);
system_request(system_reset_request, sizeof(system_reset_request));
CHECK(system_execute() == IEC104_SYSTEM_COMMAND_EXECUTE_OK); system_flush();
CHECK(system_status.ack_pending && !system_status.reset_ready);
if (mode < 3U) {
fake.now = mode == 0U ? 30000U : mode == 1U ? 32000U : 31000U;
system_ack_all();
} else {
ack_override = IEC104_SLAVE_ACK_ACKED;
ack_override_time = 999U;
}
if (mode == 0U) { fake.now = 32000U; }
CHECK(IEC104_SystemCommand_Process(system_command)); system_get_status();
memset(&request, 0x5a, sizeof(request)); unchanged = request;
if (mode == 0U || mode == 4U) {
CHECK(system_status.reset_ready && !system_status.timer_active && system_status.ack_timeouts == 0U);
CHECK(IEC104_SystemCommand_Take_Reset(system_command, &request));
CHECK(request.identity.slave == system_slave && request.identity.generation != 0U && request.qualifier == 1U);
CHECK(!IEC104_SystemCommand_Take_Reset(system_command, &request));
} else {
CHECK(system_status.ack_timeouts == 1U && system_status.reset_cancelled == 1U);
CHECK(!IEC104_SystemCommand_Take_Reset(system_command, &request));
CHECK(memcmp(&request, &unchanged, sizeof(request)) == 0);
}
system_close(); ++system_groups;
}
}
/**
* 功能:验证以下场景与约束:[105/PENDING_TIMEOUT] QRP1尚未交给发送层即超时,原FIFO槽改为否定ACT_CON。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:mode0覆盖持续WAIT及期限前一毫秒/恰好到期;mode1覆盖回调耗时耗尽整个ACK业务期限。
* 否定继续WAIT时不得再占复位授权、观察槽或站点引用,也不能留下零超时唤醒或重复动作。
*/
static void test_system_reset_pending_timeout(void)
{
unsigned mode;
for (mode = 0U; mode < 2U; ++mode) {
IEC104_SystemCommandResetRequest_t output, unchanged;
uint8_t request[10], expected[10], following[18];
const unsigned replies = IEC104_SYSTEM_COMMAND_TASK_CAPACITY > 1U ? 2U : 1U;
system_open(100U, 10U);
memcpy(request, system_reset_request, sizeof(request)); request[3] = 0x61U;
memcpy(expected, request, sizeof(expected)); expected[2] = 0x47U;
memcpy(following, system_test_request, sizeof(following)); following[4] = 2U;
ack_submit_wait = 1;
if (mode == 1U) { action_advance = 10U; }
system_request(request, sizeof(request));
CHECK(system_execute() == IEC104_SYSTEM_COMMAND_EXECUTE_OK && action_calls == 1U);
if (replies == 2U) {
/* 后继107使用另一站,既核对FIFO顺序,也能单独证明原复位站引用已经释放。 */
CHECK(IEC104_Slave_Add_Station(system_slave, &system_stations[1], 2U, NULL) == IEC104_STATION_OK);
system_request(following, sizeof(following));
}
if (mode == 0U) {
system_flush(); fake.now = 1009U;
CHECK(IEC104_SystemCommand_Process(system_command)); system_get_status();
CHECK(system_frame_count() == 0U && system_status.pending_tasks == replies);
CHECK(system_status.timer_active && system_status.timeout_remaining_ms == 1U);
CHECK(system_status.reset_cancelled == 0U && system_status.reset_refused == 0U);
CHECK(system_status.ack_timeouts == 0U && system_status.send_waiting);
}
CHECK(IEC104_Slave_Remove_Station(system_slave, &system_stations[0]) == IEC104_STATION_OK);
CHECK(!IEC104_Station_Is_Reusable(&system_stations[0]));
fake.now = 1010U; send_wait_type = 105;
CHECK(IEC104_SystemCommand_Process(system_command)); system_get_status();
CHECK(system_frame_count() == 0U && system_status.pending_tasks == replies);
CHECK(system_status.reset_refused == 1U && system_status.reset_cancelled == 1U);
CHECK(system_status.ack_timeouts == 1U && system_status.reset_cancelled_handed == 0U);
CHECK(!system_status.ack_pending && !system_status.reset_ready && system_ack_watch_count() == 0U);
CHECK(system_status.send_waiting && !system_status.timer_active && !system_status.need_process);
CHECK(IEC104_Station_Is_Reusable(&system_stations[0]));
memset(&output, 0x5a, sizeof(output)); memcpy(&unchanged, &output, sizeof(output));
CHECK(!IEC104_SystemCommand_Take_Reset(system_command, &output));
CHECK(memcmp(&output, &unchanged, sizeof(output)) == 0);
CHECK(system_execute() == IEC104_SYSTEM_COMMAND_EXECUTE_EMPTY && action_calls == 1U);
fake.now += 100U; system_flush();
CHECK(system_frame_count() == 0U && system_status.pending_tasks == replies);
CHECK(system_status.reset_refused == 1U && system_status.reset_cancelled == 1U);
CHECK(system_status.ack_timeouts == 1U && !system_status.timer_active && !system_status.need_process);
/* 保持肯定ACK提交钩子为WAIT:否定必须改走普通回复,不得保留reset_confirm。 */
send_wait_type = 0; system_flush();
CHECK(system_frame_count() == replies && system_status.pending_tasks == 0U);
system_expect(0U, expected, sizeof(expected));
if (replies == 2U) { following[2] = 7U; system_expect(1U, following, sizeof(following)); }
CHECK(system_status.negative_submitted == 1U && system_status.submitted == replies);
CHECK(action_calls == 1U && system_ack_watch_count() == 0U);
system_ack_all(); CHECK(IEC104_SystemCommand_Process(system_command)); system_get_status();
CHECK(system_frame_count() == replies && !system_status.reset_ready && !system_status.timer_active);
CHECK(!IEC104_SystemCommand_Take_Reset(system_command, &output));
CHECK(memcmp(&output, &unchanged, sizeof(output)) == 0);
system_close(); ++system_groups;
}
}
/**
* 功能:验证以下场景与约束:同一提交前期限恰好到点时,显式Cancel、STOP和断线仍是清理,不新建否定回复。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:生命周期优先于正常Process的超时转换;取消后的恢复/重连不能补发旧确认。
*/
static void test_system_reset_pending_timeout_cleanup(void)
{
unsigned mode;
for (mode = 0U; mode < 3U; ++mode) {
IEC104_SystemCommandResetRequest_t output;
system_open(100U, 10U); ack_submit_wait = 1;
system_request(system_reset_request, sizeof(system_reset_request));
CHECK(system_execute() == IEC104_SYSTEM_COMMAND_EXECUTE_OK); system_flush();
CHECK(system_frame_count() == 0U && system_status.pending_tasks == 1U);
fake.now = 1010U;
if (mode == 0U) { IEC104_SystemCommand_Cancel(system_command); }
else {
if (mode == 1U) { push(stop_act, sizeof(stop_act)); }
else { fake.recv_eof = 1U; }
system_poll(); fake.recv_eof = 0U;
}
ack_submit_wait = 0; system_flush();
CHECK(system_status.pending_tasks == 0U && system_status.reset_cancelled == 1U);
CHECK(system_status.reset_refused == 0U && system_status.negative_submitted == 0U);
CHECK(system_status.reset_cancelled_handed == 0U && system_ack_watch_count() == 0U);
CHECK(system_frame_count() == 0U && action_calls == 1U && !system_status.timer_active);
CHECK(!IEC104_SystemCommand_Take_Reset(system_command, &output));
CHECK(IEC104_Slave_Remove_Station(system_slave, &system_stations[0]) == IEC104_STATION_OK);
CHECK(IEC104_Station_Is_Reusable(&system_stations[0]));
if (mode != 0U) {
if (mode == 2U) { fake.accept_pending = 1U; system_poll(); }
push(start_act, sizeof(start_act)); system_poll(); system_flush();
CHECK(system_status.active && system_frame_count() == 0U);
}
system_close(); ++system_groups;
}
}
/**
* 功能:验证以下场景与约束:[105/FIFO_CANCEL] 待提交确认不能让后续107抢先。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:取消已交发送层确认不恢复授权。
*/
static void test_system_reset_order_and_cancel(void)
{
unsigned mode;
if (IEC104_SYSTEM_COMMAND_TASK_CAPACITY > 1U) {
const uint8_t *frames[64]; size_t lengths[64];
system_open(100U, 100U); ack_submit_wait = 1;
system_queue(system_reset_request, sizeof(system_reset_request));
system_queue(system_test_request, sizeof(system_test_request)); system_poll();
CHECK(system_execute() == IEC104_SYSTEM_COMMAND_EXECUTE_OK); system_flush();
CHECK(system_frame_count() == 0U && system_status.pending_tasks == 2U && system_status.send_waiting);
ack_submit_wait = 0; system_flush();
CHECK(system_collect(frames, lengths) == 2U && frames[0][0] == 105U && frames[1][0] == 107U);
system_close(); ++system_groups;
}
for (mode = 0U; mode < 4U; ++mode) {
IEC104_SystemCommandResetRequest_t request;
system_open(100U, 100U);
if (mode == 0U) { ack_submit_wait = 1; }
system_request(system_reset_request, sizeof(system_reset_request));
CHECK(system_execute() == IEC104_SYSTEM_COMMAND_EXECUTE_OK); system_flush();
if (mode == 2U) { system_ack_all(); CHECK(IEC104_SystemCommand_Process(system_command)); }
if (mode == 3U) { push(stop_act, sizeof(stop_act)); system_poll(); }
else { IEC104_SystemCommand_Cancel(system_command); }
ack_submit_wait = 0; system_flush(); system_ack_all();
CHECK(IEC104_SystemCommand_Process(system_command)); system_get_status();
CHECK(!IEC104_SystemCommand_Take_Reset(system_command, &request));
CHECK(system_status.reset_cancelled == 1U);
CHECK(system_status.reset_cancelled_handed == (mode == 0U ? 0U : 1U));
if (mode == 0U) { CHECK(system_frame_count() == 0U); }
system_close(); ++system_groups;
}
/* k=1先用107占窗口,QRP1确认留HIGH。业务超时释放观察槽,随后确认仍可正常发出。 */
system_window = 1U; system_open(100U, 10U);
system_request(system_test_request, sizeof(system_test_request)); system_flush();
system_request(system_reset_request, sizeof(system_reset_request));
CHECK(system_execute() == IEC104_SYSTEM_COMMAND_EXECUTE_OK); system_flush();
CHECK(system_frame_count() == 1U); fake.now += 10U;
CHECK(IEC104_SystemCommand_Process(system_command)); system_get_status();
CHECK(system_status.ack_timeouts == 1U && system_status.reset_cancelled_handed == 1U);
CHECK(system_status.reset_refused == 0U && system_status.negative_submitted == 0U);
system_ack_all(); system_flush(); CHECK(system_frame_count() == 2U);
system_expect(1U, system_reset_confirmation, sizeof(system_reset_confirmation));
system_ack_all(); CHECK(IEC104_SystemCommand_Process(system_command));
{
IEC104_SystemCommandResetRequest_t request;
CHECK(!IEC104_SystemCommand_Take_Reset(system_command, &request));
}
system_close(); ++system_groups;
}
/**
* 功能:验证以下场景与约束:[105/QUERY_ERRORS] 状态查询失败不改输出。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:Process实际清理观察槽和原站引用。
*/
static void test_system_ack_errors_and_busy(void)
{
IEC104_SystemCommandStatus_t result, unchanged;
system_open(100U, 0U); system_request(system_reset_request, sizeof(system_reset_request));
CHECK(system_execute() == IEC104_SYSTEM_COMMAND_EXECUTE_OK); system_flush();
system_request(system_reset_request, sizeof(system_reset_request));
CHECK(system_execute() == IEC104_SYSTEM_COMMAND_EXECUTE_OK); system_flush();
CHECK(action_calls == 1U && system_status.reset_busy == 1U);
ack_override = IEC104_SLAVE_ACK_ERROR;
memset(&result, 0xa5, sizeof(result)); unchanged = result;
CHECK(!IEC104_SystemCommand_Get_Status(system_command, &result));
CHECK(memcmp(&result, &unchanged, sizeof(result)) == 0);
CHECK(!IEC104_SystemCommand_Process(system_command)); ack_override = -9;
system_get_status(); CHECK(!system_status.ack_pending && system_status.reset_cancelled == 1U);
system_close(); ++system_groups;
}
/**
* 功能:验证以下场景与约束:[105/SESSION_BOUNDARY] 用真实S帧ACK区分传输事实与业务承诺,不注入ACK查询结果。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:三个阶段各遇一次STOP和EOF:ACKED但尚未Process、READY未Take、Take已成功。
* 先保留生命周期通知,检查Take不能越过FIFO;再分派并核对保留/交出计数及资源释放。
* 资源断言放在system_close之前,防止fixture的Cancel/Close掩盖业务释放遗漏。
*/
static void test_system_reset_session_boundaries(void)
{
enum { ACKED_BEFORE_PROCESS, READY_BEFORE_TAKE, TAKEN_BY_APPLICATION };
unsigned phase, disconnected;
for (phase = ACKED_BEFORE_PROCESS; phase <= TAKEN_BY_APPLICATION; ++phase) {
for (disconnected = 0U; disconnected < 2U; ++disconnected) {
IEC104_SystemCommandResetRequest_t request, unchanged;
IEC104_SlaveEventIdentity_t identity;
uint64_t acked_at_ms = 0U, station_id;
const bool taken = phase == TAKEN_BY_APPLICATION;
system_prepare_reset(100U, &identity);
station_id = IEC104_Station_Get_Id(&system_stations[0]);
++fake.now;
system_ack_all(); /* 仅Poll并读空通知,不调用SystemCommand_Process。 */
CHECK(IEC104_Slave_Get_Active_Ack_State(system_slave, &system_reset_receipt, &acked_at_ms) ==
IEC104_SLAVE_ACK_ACKED);
CHECK(acked_at_ms == fake.now);
system_get_status();
CHECK(!system_status.ack_pending && !system_status.reset_ready && system_status.need_process);
memset(&request, 0x5a, sizeof(request));
memcpy(&unchanged, &request, sizeof(request));
CHECK(!IEC104_SystemCommand_Take_Reset(system_command, &request));
CHECK(memcmp(&request, &unchanged, sizeof(request)) == 0);
if (phase != ACKED_BEFORE_PROCESS) {
CHECK(IEC104_SystemCommand_Process(system_command));
system_get_status();
CHECK(system_status.reset_ready && !system_status.timer_active);
}
if (taken) {
CHECK(IEC104_SystemCommand_Take_Reset(system_command, &request));
system_expect_reset_identity(&request, &identity, station_id);
memcpy(&unchanged, &request, sizeof(request)); /* 应用已取得的纯值请求。 */
system_expect_reset_released();
}
system_get_status();
CHECK(system_status.reset_cancelled == 0U && system_status.resets_released == (taken ? 1U : 0U));
if (disconnected) { fake.recv_eof = 1U; }
else { push(stop_act, sizeof(stop_act)); }
CHECK(IEC104_Slave_Poll(system_slave, 0U, NULL) == IEC104_TCP_OK);
fake.recv_eof = 0U;
/* 通知尚未分派时,Process只能让出,不能凭ACK抢先交出授权。 */
system_get_status(); CHECK(system_status.events_pending);
CHECK(IEC104_Slave_Get_Ack_State(system_slave, &system_reset_receipt, NULL) ==
(taken ? IEC104_SLAVE_ACK_ERROR : IEC104_SLAVE_ACK_ACKED));
CHECK(IEC104_Slave_Get_Active_Ack_State(system_slave, &system_reset_receipt, NULL) ==
(taken ? IEC104_SLAVE_ACK_ERROR : IEC104_SLAVE_ACK_ACKED));
CHECK(IEC104_SystemCommand_Process(system_command));
CHECK(!IEC104_SystemCommand_Take_Reset(system_command, &request));
CHECK(memcmp(&request, &unchanged, sizeof(request)) == 0);
system_get_status();
CHECK(system_status.reset_ready == (phase == READY_BEFORE_TAKE));
CHECK(system_status.reset_cancelled == 0U && system_status.resets_released == (taken ? 1U : 0U));
system_drain(); system_get_status();
CHECK(!system_status.active && !system_status.events_pending && system_status.reset_ready == !taken);
CHECK(!system_status.ack_pending && !system_status.timer_active && !system_status.need_process);
CHECK(system_status.generation == (disconnected ? 0U : identity.generation));
CHECK(system_status.reset_cancelled == 0U && system_status.reset_cancelled_handed == 0U);
CHECK(system_status.resets_released == (taken ? 1U : 0U) && system_status.ack_timeouts == 0U);
CHECK(system_status.reset_accepted == 1U && system_status.cancelled == 0U);
CHECK(system_status.pending_tasks == 0U && system_ack_watch_count() == (taken ? 0U : 1U));
CHECK(IEC104_SystemCommand_Process(system_command)); /* 停用状态也不能取消已经提交的承诺。 */
if (!taken) {
CHECK(IEC104_SystemCommand_Take_Reset(system_command, &request));
system_expect_reset_identity(&request, &identity, station_id);
memcpy(&unchanged, &request, sizeof(request));
system_expect_reset_released();
}
CHECK(!IEC104_SystemCommand_Take_Reset(system_command, &request));
CHECK(memcmp(&request, &unchanged, sizeof(request)) == 0);
/* 已交出请求不会因同连接START或新连接START再次出现。 */
if (disconnected) { fake.accept_pending = 1U; system_ns = 0U; system_poll(); }
push(start_act, sizeof(start_act)); system_poll(); system_flush();
CHECK(system_status.active && system_status.generation != 0U);
CHECK((system_status.generation != identity.generation) == (disconnected != 0U));
CHECK(!system_status.reset_ready && !system_status.ack_pending && !system_status.need_process);
CHECK(system_status.reset_cancelled == 0U && system_status.reset_cancelled_handed == 0U);
CHECK(system_status.resets_released == 1U && system_status.ack_timeouts == 0U);
CHECK(system_frame_count() == 1U && action_calls == 1U && system_ack_watch_count() == 0U);
CHECK(!IEC104_SystemCommand_Take_Reset(system_command, &request));
CHECK(memcmp(&request, &unchanged, sizeof(request)) == 0);
system_close(); ++system_groups;
}
}
}
/**
* 功能:验证以下场景与约束:[105/ACK_ORDER] 帧顺序由同一接收缓冲中的真实S/U帧决定。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:fake.now保持不变,
* 因此不能靠毫秒时间戳区分“ACK后STOP”和“STOP后ACK”。通用观察仍报告迟到ACK事实,
* Active观察必须永久保留首次STOP屏障,后来的START不能让旧复位复活。
*/
static void test_system_reset_ack_stop_order(void)
{
unsigned mode;
for (mode = 0U; mode < 3U; ++mode) {
IEC104_SlaveEventIdentity_t identity;
IEC104_SystemCommandResetRequest_t request, unchanged;
uint64_t station_id, acked_at_ms = 0U, active_time = UINT64_MAX;
const bool committed = mode == 0U;
system_prepare_reset(100U, &identity);
station_id = IEC104_Station_Get_Id(&system_stations[0]);
memset(&request, 0x5a, sizeof(request)); memcpy(&unchanged, &request, sizeof(request));
if (committed) { push_ack(sut->connection.link_state.vs); }
push(stop_act, sizeof(stop_act));
if (mode == 2U) { push(start_act, sizeof(start_act)); }
if (!committed) { push_ack(sut->connection.link_state.vs); }
CHECK(IEC104_Slave_Poll(system_slave, 0U, NULL) == IEC104_TCP_OK);
CHECK(fake.now == 1000U);
CHECK(IEC104_Slave_Get_Ack_State(system_slave, &system_reset_receipt, &acked_at_ms) ==
IEC104_SLAVE_ACK_ACKED);
CHECK(acked_at_ms == fake.now);
CHECK(IEC104_Slave_Get_Active_Ack_State(system_slave, &system_reset_receipt, &active_time) ==
(committed ? IEC104_SLAVE_ACK_ACKED : IEC104_SLAVE_ACK_LOST));
CHECK(active_time == (committed ? fake.now : UINT64_MAX));
system_get_status(); CHECK(system_status.events_pending && !system_status.reset_ready);
CHECK(IEC104_SystemCommand_Process(system_command));
CHECK(!IEC104_SystemCommand_Take_Reset(system_command, &request));
CHECK(memcmp(&request, &unchanged, sizeof(request)) == 0);
system_drain(); system_get_status();
CHECK(system_status.active == (mode == 2U));
CHECK(system_status.reset_ready == committed && !system_status.timer_active);
CHECK(system_status.reset_cancelled == (committed ? 0U : 1U));
CHECK(system_status.reset_cancelled_handed == (committed ? 0U : 1U));
CHECK(system_status.ack_timeouts == 0U && system_status.resets_released == 0U);
CHECK(IEC104_SystemCommand_Take_Reset(system_command, &request) == committed);
if (committed) {
system_expect_reset_identity(&request, &identity, station_id);
memcpy(&unchanged, &request, sizeof(request));
} else { CHECK(memcmp(&request, &unchanged, sizeof(request)) == 0); }
system_expect_reset_released();
/* 新START及重复ACK都不应重新提交或恢复任何已交出/取消的请求。 */
if (mode != 2U) { push(start_act, sizeof(start_act)); system_poll(); }
push_ack(sut->connection.link_state.vs); system_poll(); system_flush();
CHECK(!IEC104_SystemCommand_Take_Reset(system_command, &request));
CHECK(memcmp(&request, &unchanged, sizeof(request)) == 0);
CHECK(system_status.reset_cancelled == (committed ? 0U : 1U));
CHECK(system_status.resets_released == (committed ? 1U : 0U));
CHECK(!system_status.reset_ready && !system_status.ack_pending && system_ack_watch_count() == 0U);
CHECK(system_frame_count() == 1U && action_calls == 1U);
system_close(); ++system_groups;
}
}
/**
* 功能:验证以下场景与约束:ACK事实先于业务期限判断。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:STOP已让Active观察LOST时按会话取消,不能伪记ACK超时。
* mode0:及时ACK但业务处理时已过期;mode1/2:恰好截止/超过截止ACK后STOP;mode3:截止时仅STOP。
*/
static void test_system_reset_stop_deadlines(void)
{
unsigned mode;
for (mode = 0U; mode < 4U; ++mode) {
IEC104_SlaveEventIdentity_t identity;
IEC104_SystemCommandResetRequest_t request, unchanged;
uint64_t station_id, acked_at_ms = UINT64_MAX;
const bool committed = mode == 0U;
system_prepare_reset(100U, &identity);
station_id = IEC104_Station_Get_Id(&system_stations[0]);
memset(&request, 0x5a, sizeof(request)); memcpy(&unchanged, &request, sizeof(request));
if (committed) {
fake.now = 1099U;
system_ack_all(); /* 尚未Process;历史ACK时间仍为1099。 */
fake.now = 1101U;
} else {
fake.now = mode == 2U ? 1101U : 1100U;
if (mode != 3U) { push_ack(sut->connection.link_state.vs); }
}
push(stop_act, sizeof(stop_act));
CHECK(IEC104_Slave_Poll(system_slave, 0U, NULL) == IEC104_TCP_OK);
CHECK(IEC104_Slave_Get_Active_Ack_State(system_slave, &system_reset_receipt, &acked_at_ms) ==
(mode == 3U ? IEC104_SLAVE_ACK_LOST : IEC104_SLAVE_ACK_ACKED));
CHECK(acked_at_ms == (mode == 3U ? UINT64_MAX : committed ? 1099U : fake.now));
system_drain(); system_get_status();
CHECK(!system_status.active && !system_status.timer_active && system_status.reset_ready == committed);
CHECK(system_status.reset_cancelled == (committed ? 0U : 1U));
CHECK(system_status.reset_cancelled_handed == (committed ? 0U : 1U));
CHECK(system_status.ack_timeouts == (mode == 1U || mode == 2U ? 1U : 0U));
CHECK(IEC104_SystemCommand_Take_Reset(system_command, &request) == committed);
if (committed) { system_expect_reset_identity(&request, &identity, station_id); }
else { CHECK(memcmp(&request, &unchanged, sizeof(request)) == 0); }
system_expect_reset_released();
system_close(); ++system_groups;
}
}
/**
* 功能:验证以下场景与约束:ACKED尚未Process及READY两种入口均跨DISCONNECTED、CONNECTED、ACTIVATED保留。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:原请求属于旧代次,不能被重绑为新代次。已提交承诺仍可由显式Cancel撤销。
*/
static void test_system_reset_commit_reconnect(void)
{
unsigned advanced;
for (advanced = 0U; advanced < 2U; ++advanced) {
IEC104_SlaveEventIdentity_t identity;
IEC104_SystemCommandResetRequest_t request, unchanged;
uint64_t station_id;
system_prepare_reset(100U, &identity);
station_id = IEC104_Station_Get_Id(&system_stations[0]);
system_ack_all();
if (advanced) { CHECK(IEC104_SystemCommand_Process(system_command)); }
fake.recv_eof = 1U; system_poll(); fake.recv_eof = 0U;
system_get_status();
CHECK(system_status.generation == 0U && system_status.reset_ready && !system_status.active);
CHECK(!system_status.timer_active && !system_status.need_process && system_ack_watch_count() == 1U);
CHECK(!IEC104_SystemCommand_Destroy(system_command));
/* 旧站退役后,承诺仍持有原节点;新连接不取得原引用的所有权。 */
CHECK(IEC104_Slave_Remove_Station(system_slave, &system_stations[0]) == IEC104_STATION_OK);
CHECK(!IEC104_Station_Is_Reusable(&system_stations[0]));
CHECK(IEC104_Slave_Add_Station(system_slave, &system_stations[1], 1U, &application_cleared) == IEC104_STATION_OK);
fake.accept_pending = 1U; system_ns = 0U; system_poll();
push(start_act, sizeof(start_act)); system_poll(); system_flush();
CHECK(system_status.active && system_status.generation != 0U && system_status.generation != identity.generation);
CHECK(system_status.reset_ready && !system_status.ack_pending && system_status.reset_cancelled == 0U);
CHECK(system_status.resets_released == 0U && system_ack_watch_count() == 1U);
CHECK(IEC104_SystemCommand_Take_Reset(system_command, &request));
system_expect_reset_identity(&request, &identity, station_id);
CHECK(request.station_id != IEC104_Station_Get_Id(&system_stations[1]));
CHECK(IEC104_Station_Is_Reusable(&system_stations[0]) && system_ack_watch_count() == 0U);
CHECK(IEC104_Slave_Get_Active_Ack_State(system_slave, &system_reset_receipt, NULL) == IEC104_SLAVE_ACK_ERROR);
memcpy(&unchanged, &request, sizeof(request));
CHECK(!IEC104_SystemCommand_Take_Reset(system_command, &request));
CHECK(memcmp(&request, &unchanged, sizeof(request)) == 0);
system_flush();
CHECK(!system_status.reset_ready && system_status.resets_released == 1U && system_status.reset_cancelled == 0U);
CHECK(system_frame_count() == 1U && action_calls == 1U);
system_close(); ++system_groups;
}
{
IEC104_SlaveEventIdentity_t identity;
IEC104_SystemCommandResetRequest_t request, unchanged;
system_prepare_reset(100U, &identity);
system_ack_all(); push(stop_act, sizeof(stop_act)); system_poll();
system_get_status(); CHECK(system_status.reset_ready && system_ack_watch_count() == 1U);
IEC104_SystemCommand_Cancel(system_command);
system_get_status();
CHECK(!system_status.reset_ready && system_status.reset_cancelled == 1U);
CHECK(system_status.reset_cancelled_handed == 1U && system_status.ack_timeouts == 0U);
CHECK(system_status.resets_released == 0U);
memset(&request, 0x5a, sizeof(request)); memcpy(&unchanged, &request, sizeof(request));
CHECK(!IEC104_SystemCommand_Take_Reset(system_command, &request));
CHECK(memcmp(&request, &unchanged, sizeof(request)) == 0);
system_expect_reset_released();
system_close(); ++system_groups;
}
}
/**
* 功能:验证以下场景与约束:[105/CLOSE_BOUNDARY] 服务Close有意清空ACK观察,不等同于保留历史观察的普通EOF。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:READY已经冻结业务决定,不再依赖观察槽;仅ACKED而尚未Process时查询必须报ERROR,
* Handle_Event仍归还原站引用并返回错误,不能把查询失败伪装成未ACK或构造READY。
*/
static void test_system_reset_service_close(void)
{
unsigned advanced;
for (advanced = 0U; advanced < 2U; ++advanced) {
IEC104_SlaveEventIdentity_t identity;
IEC104_SystemCommandResetRequest_t request, unchanged;
IEC104_SystemCommandStatus_t status, unchanged_status;
IEC104_SlaveEvent_t event;
uint64_t station_id, acked_at_ms = UINT64_MAX;
system_prepare_reset(100U, &identity);
station_id = IEC104_Station_Get_Id(&system_stations[0]);
system_ack_all();
CHECK(IEC104_Slave_Get_Active_Ack_State(system_slave, &system_reset_receipt, NULL) == IEC104_SLAVE_ACK_ACKED);
if (advanced) { CHECK(IEC104_SystemCommand_Process(system_command)); }
system_get_status();
CHECK(system_status.reset_ready == (advanced != 0U) && !system_status.ack_pending);
CHECK(system_ack_watch_count() == 1U && system_status.reset_cancelled == 0U);
memset(&request, 0x5a, sizeof(request)); memcpy(&unchanged, &request, sizeof(request));
CHECK(IEC104_Slave_Close(system_slave, NULL) == IEC104_TCP_OK);
CHECK(system_ack_watch_count() == 0U);
CHECK(IEC104_Slave_Get_Ack_State(system_slave, &system_reset_receipt, &acked_at_ms) == IEC104_SLAVE_ACK_ERROR);
CHECK(IEC104_Slave_Get_Active_Ack_State(system_slave, &system_reset_receipt, &acked_at_ms) == IEC104_SLAVE_ACK_ERROR);
CHECK(acked_at_ms == UINT64_MAX);
memset(&status, 0xa5, sizeof(status)); memcpy(&unchanged_status, &status, sizeof(status));
CHECK(IEC104_SystemCommand_Get_Status(system_command, &status) == (advanced != 0U));
if (advanced) { CHECK(status.reset_ready && status.events_pending && status.reset_cancelled == 0U); }
else { CHECK(memcmp(&status, &unchanged_status, sizeof(status)) == 0); }
CHECK(!IEC104_SystemCommand_Take_Reset(system_command, &request)); /* 尚有DISCONNECTED待分派。 */
CHECK(memcmp(&request, &unchanged, sizeof(request)) == 0);
/* ACK记录已由system_ack_all读空;Close此时只新交付一个DISCONNECTED。 */
CHECK(IEC104_Slave_NextEvent(system_slave, &event) == IEC104_TCP_EVENT_READY);
CHECK(event.transport.type == IEC104_TCP_EVENT_DISCONNECTED);
CHECK(IEC104_SystemCommand_Handle_Event(system_command, &event) ==
(advanced ? IEC104_SYSTEM_COMMAND_EVENT_HANDLED : IEC104_SYSTEM_COMMAND_EVENT_ERROR));
CHECK(IEC104_Slave_NextEvent(system_slave, &event) == IEC104_TCP_EVENT_EMPTY);
system_get_status();
CHECK(!system_status.active && system_status.generation == 0U && !system_status.events_pending);
CHECK(system_status.reset_ready == (advanced != 0U) && !system_status.ack_pending);
CHECK(!system_status.timer_active && !system_status.need_process && system_status.pending_tasks == 0U);
CHECK(system_status.reset_cancelled == (advanced ? 0U : 1U));
CHECK(system_status.reset_cancelled_handed == (advanced ? 0U : 1U));
CHECK(system_status.ack_timeouts == 0U && system_status.resets_released == 0U);
CHECK(IEC104_SystemCommand_Take_Reset(system_command, &request) == (advanced != 0U));
if (advanced) {
system_expect_reset_identity(&request, &identity, station_id);
memcpy(&unchanged, &request, sizeof(request));
} else { CHECK(memcmp(&request, &unchanged, sizeof(request)) == 0); }
system_expect_reset_released();
CHECK(!IEC104_SystemCommand_Take_Reset(system_command, &request));
CHECK(memcmp(&request, &unchanged, sizeof(request)) == 0);
CHECK(IEC104_SystemCommand_Process(system_command)); /* 故障已清理,不重复取消或重复报错。 */
system_get_status();
CHECK(!system_status.reset_ready && system_status.resets_released == (advanced ? 1U : 0U));
CHECK(system_status.reset_cancelled == (advanced ? 0U : 1U) && system_status.cancelled == 0U);
system_close(); ++system_groups;
}
}
/**
* 功能:验证以下场景与约束:[105/QRP2] 先预检再应用动作。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:清除失败保留否定回复,WAIT不得重复动作/清除。
*/
static void test_system_clear_results(void)
{
unsigned mode;
for (mode = 0U; mode < 4U; ++mode) {
uint8_t request[10], expected[10];
memcpy(request, system_reset_request, sizeof(request)); request[9] = 2U;
memcpy(expected, request, sizeof(expected)); expected[2] = mode == 0U ? 7U : 0x47U;
system_open(100U, 100U);
if (mode == 1U) { count_failure = 1; }
if (mode == 2U) { discard_failure = 1; }
if (mode == 3U) { action_mode = 2U; }
system_request(request, sizeof(request));
CHECK(system_execute() == (mode == 2U ? IEC104_SYSTEM_COMMAND_EXECUTE_FAULT : IEC104_SYSTEM_COMMAND_EXECUTE_OK));
send_wait_type = 105; system_flush();
CHECK(action_calls == (mode == 1U ? 0U : 1U));
CHECK(discard_calls == (mode == 0U || mode == 2U ? 1U : 0U));
CHECK(application_cleared == (mode == 0U || mode == 2U ? 1U : 0U));
CHECK(system_execute() == IEC104_SYSTEM_COMMAND_EXECUTE_EMPTY);
send_wait_type = 0; system_flush(); system_expect(0U, expected, sizeof(expected));
CHECK(system_status.partial_failures == (mode == 2U ? 1U : 0U));
system_close(); ++system_groups;
}
{
uint8_t request[10];
memcpy(request, system_reset_request, sizeof(request)); request[9] = 2U;
system_open(10U, 100U); count_advance = 10U;
system_request(request, sizeof(request));
CHECK(system_execute() == IEC104_SYSTEM_COMMAND_EXECUTE_OK); system_get_status();
CHECK(action_calls == 0U && discard_calls == 0U && system_status.timeouts == 1U);
system_flush(); CHECK(system_status.negative_submitted == 1U);
system_close(); ++system_groups;
}
}
/**
* 功能:验证以下场景与约束:同CA/其他CA及有无时标混排。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:同时验证原站删除后不把旧请求授权给新注册节点。
*/
static void test_system_clear_ca_and_station(void)
{
uint8_t request[10]; uint32_t count;
memcpy(request, system_reset_request, sizeof(request)); request[9] = 2U;
system_window = 1U; system_open(100U, 100U);
system_request(system_test_request, sizeof(system_test_request)); system_flush(); /* 占据k窗口。 */
system_enqueue(1U, true); system_enqueue(2U, true); system_enqueue(1U, false);
system_request(request, sizeof(request)); CHECK(system_execute() == IEC104_SYSTEM_COMMAND_EXECUTE_OK);
CHECK(IEC104_Slave_Count_Pending_Events(system_slave, 1U, IEC104_SLAVE_EVENTS_TIME_TAGGED, &count, NULL) == IEC104_TCP_OK);
CHECK(count == 0U);
CHECK(IEC104_Slave_Count_Pending_Events(system_slave, 2U, IEC104_SLAVE_EVENTS_TIME_TAGGED, &count, NULL) == IEC104_TCP_OK);
CHECK(count == 1U);
system_get_status(); CHECK(system_status.events_discarded == 1U && system_status.events_cleared_requests == 1U);
system_close(); ++system_groups;
system_open(100U, 100U); system_request(request, sizeof(request));
CHECK(IEC104_Slave_Remove_Station(system_slave, &system_stations[0]) == IEC104_STATION_OK);
CHECK(!IEC104_Station_Is_Reusable(&system_stations[0]));
CHECK(IEC104_Slave_Add_Station(system_slave, &system_stations[1], 1U, NULL) == IEC104_STATION_OK);
CHECK(system_execute() == IEC104_SYSTEM_COMMAND_EXECUTE_OK); system_flush();
CHECK(action_calls == 0U && discard_calls == 0U && system_status.station_mismatches == 1U);
CHECK(IEC104_Station_Is_Reusable(&system_stations[0])); system_close(); ++system_groups;
}
/**
* 功能:验证以下场景与约束:[FAILURES] 关闭期限也不能把查询ERROR永远当作等待。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:正常STOP的ERROR须让通知决定取消。
*/
static void test_system_submission_failures(void)
{
unsigned mode;
for (mode = 0U; mode < 4U; ++mode) {
system_open(0U, 0U);
system_request(system_test_request, sizeof(system_test_request));
if (mode == 0U) { send_wait_type = 107; }
else { send_failure = (int)mode; }
CHECK(IEC104_SystemCommand_Process(system_command));
system_get_status();
if (mode == 0U) {
CHECK(system_status.send_waiting && !system_status.need_process && system_status.pending_tasks == 1U);
send_wait_type = 0; system_flush(); CHECK(system_status.test_answered == 1U);
} else if (mode == 3U) {
CHECK(system_status.events_pending && system_status.pending_tasks == 1U);
send_failure = 0; system_drain(); system_get_status();
CHECK(system_status.cancelled == 1U && !system_status.active);
} else { CHECK(system_status.cancelled == 1U && system_status.pending_tasks == 0U); }
system_close(); ++system_groups;
}
{
IEC104_SystemCommandStatus_t status, unchanged;
system_open(0U, 0U); handoff_override = IEC104_RESPONSE_PENDING;
CHECK(IEC104_SystemCommand_Set_Initialization(system_command, 0U)); system_flush();
handoff_override = IEC104_RESPONSE_ERROR;
memset(&status, 0x5a, sizeof(status)); unchanged = status;
CHECK(!IEC104_SystemCommand_Get_Status(system_command, &status));
CHECK(memcmp(&status, &unchanged, sizeof(status)) == 0);
CHECK(IEC104_SystemCommand_Process(system_command)); handoff_override = -9;
system_get_status(); CHECK(system_status.init_retries == 1U && !system_status.need_process);
system_close(); ++system_groups;
}
}
/**
* 功能:验证以下场景与约束:[LIFETIME] 旧任务不跨STOP/START。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:满槽丢新;Create/Destroy及查询输出契约。
*/
static void test_system_lifetime_and_capacity(void)
{
IEC104_SystemCommandConfig_t config;
unsigned i;
system_open(100U, 100U); test_system_config(&config);
CHECK(config.features == 15U && config.decision_timeout_ms == 15000U && config.reset_ack_timeout_ms == 30000U);
CHECK(IEC104_SystemCommand_Create(system_slave, &config) == NULL);
for (i = 0U; i <= IEC104_SYSTEM_COMMAND_TASK_CAPACITY; ++i) {
system_queue(system_test_request, sizeof(system_test_request));
}
system_poll(); system_get_status(); CHECK(system_status.overloads == 1U && system_status.dropped_requests == 1U);
CHECK(!IEC104_SystemCommand_Destroy(system_command));
push(stop_act, sizeof(stop_act)); push(start_act, sizeof(start_act)); system_poll(); system_flush();
CHECK(system_frame_count() == 0U && system_status.cancelled == IEC104_SYSTEM_COMMAND_TASK_CAPACITY);
system_request(system_test_request, sizeof(system_test_request)); system_flush(); CHECK(system_frame_count() == 1U);
system_close(); ++system_groups;
system_open(100U, 100U); system_request(system_reset_request, sizeof(system_reset_request));
push(stop_act, sizeof(stop_act)); CHECK(IEC104_Slave_Poll(system_slave, 0U, NULL) == IEC104_TCP_OK);
CHECK(system_execute() == IEC104_SYSTEM_COMMAND_EXECUTE_WAIT && action_calls == 0U);
system_drain(); CHECK(system_execute() == IEC104_SYSTEM_COMMAND_EXECUTE_EMPTY);
system_close(); ++system_groups;
/* 与示例模拟复位相同:Cancel/Close/读空/Init后业务句柄继续接受新CONNECTED。 */
system_open(100U, 100U); IEC104_SystemCommand_Cancel(system_command);
CHECK(IEC104_Slave_Close(system_slave, NULL) == IEC104_TCP_OK); system_drain();
{
IEC104_SlaveConfig_t slave_config;
test_transport_config(&slave_config);
CHECK(IEC104_Slave_Init(system_slave, &slave_config, NULL) == IEC104_TCP_OK);
}
CHECK(IEC104_SystemCommand_Set_Initialization(system_command, 2U));
fake.accept_pending = 1U; system_poll(); push(start_act, sizeof(start_act)); system_poll(); system_flush();
CHECK(system_status.init_rounds == 1U && system_status.active); system_close(); ++system_groups;
}
/**
* 功能:[105/BROADCAST] 广播只占一个FIFO任务,各站独立决定/确认/授权。
* 输入参数:context——业务回调的测试上下文;request——当前业务请求(只读)。
* 输出参数:无。
* 返回值:动作回调的接受或拒绝决定。
* 说明:即使TASK_CAPACITY=1也须工作。
* action_mode=1仅拒绝首站,用独立地址断言防止把广播授权扩大为整机复位。
*/
static IEC104_SystemCommandDecision_t system_broadcast_action(void *context,
const IEC104_SystemCommandResetRequest_t *request)
{
IEC104_Station_t *station = IEC104_Slave_Get_Station_By_Id(system_slave, request->station_id);
CHECK(context == &application_cleared);
CHECK(station != NULL && request->common_address != IEC104_CA_BROADCAST);
CHECK(IEC104_Slave_Get_Station(system_slave, request->common_address) == station);
++action_calls;
if (action_mode == 1U && request->common_address == 1U) { return IEC104_SYSTEM_COMMAND_DECISION_REJECT; }
if (request->qualifier == 2U) { ++application_cleared; }
return IEC104_SYSTEM_COMMAND_DECISION_ACCEPT;
}
/**
* 功能:将标准复位模板改为广播CA和指定QRP,通过真实接收链提交请求。
* 输入参数:qrp——复位进程限定词。
* 输出参数:无。
* 返回值:无。
* 说明:本辅助入口用于构造或核对上述测试场景,相关状态保存在当前测试夹具中。
*/
static void system_broadcast_request(uint8_t qrp)
{
uint8_t request[10];
memcpy(request, system_reset_request, sizeof(request));
request[4] = request[5] = 255U; request[9] = qrp;
system_request(request, sizeof(request));
}
/**
* 功能:用逐站判定的广播动作回调执行一次任务,并断言本次已交付动作。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。
*/
static void system_broadcast_execute(void)
{
CHECK(IEC104_SystemCommand_Execute_Next(system_command, system_broadcast_action, &application_cleared) ==
IEC104_SYSTEM_COMMAND_EXECUTE_OK);
}
/**
* 功能:独立构造指定站点的广播展开确认,核对QRP及肯定/否定COT。
* 输入参数:frame——读取结果帧或报文缓冲区;ca——公共地址;qrp——复位进程限定词;negative——是否设置否定确认标志。
* 输出参数:无。
* 返回值:无。
* 说明:本辅助入口用于构造或核对上述测试场景,相关状态保存在当前测试夹具中。
*/
static void system_broadcast_expect(unsigned frame, uint8_t ca, uint8_t qrp, bool negative)
{
uint8_t expected[10];
memcpy(expected, system_reset_confirmation, sizeof(expected));
expected[2] = negative ? 0x47U : 7U; expected[4] = ca; expected[9] = qrp;
system_expect(frame, expected, sizeof(expected));
}
/**
* 功能:注册CA=2的第二站点,为广播拆分、逐站确认和批次屏障用例准备拓扑。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。
*/
static void system_add_second_station(void)
{
CHECK(IEC104_Slave_Add_Station(system_slave, &system_stations[1], 2U, NULL) == IEC104_STATION_OK);
}
/**
* 功能:验证以下场景与约束:首站先ACK仍不能领取。
* 输入参数:ack_ms——ACK 等待期限(毫秒)。
* 输出参数:无。
* 返回值:无。
* 说明:第二站提交WAIT不重复决定,全部ACK收敛后逐站领取且仅一次。
*/
static void test_system_broadcast_reset_barrier(uint32_t ack_ms)
{
IEC104_SystemCommandResetRequest_t output, sentinel;
uint64_t first_id, second_id;
system_open(1000U, ack_ms); system_add_second_station();
first_id = IEC104_Station_Get_Id(&system_stations[0]);
second_id = IEC104_Station_Get_Id(&system_stations[1]);
system_broadcast_request(1U); system_broadcast_execute(); system_flush();
CHECK(action_calls == 1U && system_frame_count() == 1U);
system_broadcast_expect(0U, 1U, 1U, false);
system_ack_all(); CHECK(IEC104_SystemCommand_Process(system_command)); system_get_status();
CHECK(system_ack_watch_count() == 0U); /* ACK期限为0时同样归还,不能靠超时解除观察槽互等。 */
memset(&sentinel, 0xa5, sizeof(sentinel)); output = sentinel;
CHECK(!system_status.reset_ready && !IEC104_SystemCommand_Take_Reset(system_command, &output));
CHECK(memcmp(&output, &sentinel, sizeof(output)) == 0);
ack_submit_wait = 1;
system_broadcast_execute(); system_flush();
CHECK(action_calls == 2U && system_frame_count() == 1U && !system_status.reset_ready);
CHECK(IEC104_SystemCommand_Execute_Next(system_command, system_broadcast_action, &application_cleared) ==
IEC104_SYSTEM_COMMAND_EXECUTE_EMPTY);
ack_submit_wait = 0; system_flush();
system_broadcast_expect(1U, 2U, 1U, false);
CHECK(system_status.pending_tasks == 0U && system_status.ack_pending && !system_status.reset_ready);
system_ack_all(); CHECK(IEC104_SystemCommand_Process(system_command)); system_get_status();
CHECK(system_status.reset_ready && !system_status.ack_pending && system_status.reset_accepted == 1U);
CHECK(IEC104_SystemCommand_Take_Reset(system_command, &output));
CHECK(output.common_address == 1U && output.station_id == first_id);
CHECK(IEC104_SystemCommand_Take_Reset(system_command, &output));
CHECK(output.common_address == 2U && output.station_id == second_id);
CHECK(!IEC104_SystemCommand_Take_Reset(system_command, &output));
CHECK(system_ack_watch_count() == 0U && action_calls == 2U);
system_get_status(); CHECK(system_status.resets_released == 2U);
system_close(); ++system_groups;
}
/**
* 功能:验证以下场景与约束:首站拒绝不能影响后站。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:部分ACK后STOP/断线只保留已确定站,后站迟到ACK不能恢复。
*/
static void test_system_broadcast_reset_decisions_and_stop(void)
{
unsigned mode;
for (mode = 0U; mode < 3U; ++mode) {
IEC104_SystemCommandResetRequest_t output;
system_open(1000U, 1000U); system_add_second_station();
action_mode = mode == 0U ? 1U : 0U;
system_broadcast_request(1U);
system_broadcast_execute(); system_flush();
#if IEC104_TCP_ACK_WATCH_CAPACITY == 1U
/* 默认仅一个传输ACK观察槽:先冻结首站事实以归还观察槽,广播授权仍被屏障挡住。 */
if (mode != 0U) { system_ack_all(); CHECK(IEC104_SystemCommand_Process(system_command)); }
#endif
system_broadcast_execute(); system_flush();
CHECK(action_calls == 2U && system_frame_count() == 2U);
system_broadcast_expect(0U, 1U, 1U, mode == 0U);
system_broadcast_expect(1U, 2U, 1U, false);
if (mode == 0U) { system_ack_all(); CHECK(IEC104_SystemCommand_Process(system_command)); }
else {
push_ack(1U); system_poll(); /* 不调用业务Process,让会话收尾负责冻结第一站ACK事实。 */
if (mode == 1U) { push(stop_act, sizeof(stop_act)); }
else { fake.recv_eof = 1U; }
system_poll();
}
system_get_status();
CHECK(system_status.reset_ready && !system_status.ack_pending);
CHECK(IEC104_SystemCommand_Take_Reset(system_command, &output));
CHECK(output.common_address == (mode == 0U ? 2U : 1U));
CHECK(!IEC104_SystemCommand_Take_Reset(system_command, &output));
CHECK(system_ack_watch_count() == 0U);
if (mode == 1U) {
push_ack(2U); system_poll(); CHECK(IEC104_SystemCommand_Process(system_command));
CHECK(!IEC104_SystemCommand_Take_Reset(system_command, &output));
}
system_close(); ++system_groups;
}
}
/**
* 功能:验证以下场景与约束:QRP2每站仅清一次。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:快照期间新增站不加入;已取出的原站删除后不能按CA改用替代节点。
*/
static void test_system_broadcast_clear_and_snapshot(void)
{
unsigned mode;
for (mode = 0U; mode < 3U; ++mode) {
system_open(1000U, 1000U); system_add_second_station(); system_broadcast_request(2U);
send_wait_type = 105;
system_broadcast_execute(); system_flush();
CHECK(action_calls == 1U && application_cleared == 1U && discard_calls == 1U && system_frame_count() == 0U);
if (mode == 1U) {
CHECK(IEC104_Slave_Remove_Station(system_slave, &system_stations[1]) == IEC104_STATION_OK);
CHECK(IEC104_Slave_Add_Station(system_slave, &system_stations[2], 2U, NULL) == IEC104_STATION_OK);
}
send_wait_type = 0; system_flush();
system_broadcast_expect(0U, 1U, 2U, false);
if (mode != 1U) {
if (mode == 2U) {
CHECK(IEC104_Slave_Remove_Station(system_slave, &system_stations[1]) == IEC104_STATION_OK);
CHECK(IEC104_Slave_Add_Station(system_slave, &system_stations[2], 2U, NULL) == IEC104_STATION_OK);
}
system_broadcast_execute(); system_flush();
system_broadcast_expect(1U, 2U, 2U, mode == 2U);
}
CHECK(action_calls == (mode == 0U ? 2U : 1U));
CHECK(application_cleared == action_calls && discard_calls == action_calls);
CHECK(system_status.pending_tasks == 0U && !system_status.reset_ready);
system_close(); ++system_groups;
}
}
/**
* 功能:验证以下场景与约束:合法TEST和校验错误广播均逐站具体CA回显。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:空站表无可回显目标,只回原请求CA的未知CA。
*/
static void test_system_broadcast_invalid_and_empty(void)
{
unsigned mode;
for (mode = 0U; mode < 5U; ++mode) {
uint8_t request[10], expected[10];
unsigned ca;
system_open(1000U, 1000U); system_add_second_station();
memcpy(request, system_reset_request, sizeof(request)); request[4] = request[5] = 255U;
if (mode == 0U) { request[2] |= 0x80U; }
else if (mode == 1U) { request[9] = 3U; }
else if (mode == 2U) { request[2] = 8U; }
else if (mode == 3U) { request[6] = 1U; }
else {
CHECK(IEC104_Slave_Remove_Station(system_slave, &system_stations[0]) == IEC104_STATION_OK);
CHECK(IEC104_Slave_Remove_Station(system_slave, &system_stations[1]) == IEC104_STATION_OK);
}
system_request(request, sizeof(request)); system_flush();
CHECK(system_execute() == IEC104_SYSTEM_COMMAND_EXECUTE_EMPTY && action_calls == 0U);
memcpy(expected, request, sizeof(expected));
expected[2] = (uint8_t)((request[2] & 0x80U) | (mode == 0U ? 0U : 0x40U) | (mode == 2U ? 45U :
mode == 3U ? 47U : mode == 4U ? 46U : 7U));
if (mode == 4U) { system_expect(0U, expected, sizeof(expected)); CHECK(system_frame_count() == 1U); }
else {
for (ca = 1U; ca <= 2U; ++ca) {
expected[4] = (uint8_t)ca; expected[5] = 0U;
system_expect(ca - 1U, expected, sizeof(expected));
}
CHECK(system_frame_count() == 2U);
}
system_close(); ++system_groups;
}
}
/**
* 功能:验证以下场景与约束:默认4个授权槽容纳前4站,第5站在动作之前否定。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:READY不能提前领取来掩盖容量上限。
* 所有原站随后删除,Take仍返回原注册身份,快照/引用释放后节点才可回收。
*/
static void test_system_broadcast_reset_capacity(void)
{
IEC104_Station_t extra[4];
IEC104_SystemCommandResetRequest_t output;
uint64_t ids[5];
unsigned i;
memset(extra, 0, sizeof(extra));
system_open(1000U, 0U);
ids[0] = IEC104_Station_Get_Id(&system_stations[0]);
for (i = 0U; i < 4U; ++i) {
CHECK(IEC104_Slave_Add_Station(system_slave, &extra[i], (uint16_t)(i + 2U), NULL) == IEC104_STATION_OK);
ids[i + 1U] = IEC104_Station_Get_Id(&extra[i]);
}
system_broadcast_request(1U);
for (i = 0U; i < 5U; ++i) {
system_broadcast_execute(); system_flush();
system_broadcast_expect(i, (uint8_t)(i + 1U), 1U, i == 4U);
system_ack_all(); CHECK(IEC104_SystemCommand_Process(system_command)); system_get_status();
if (i < 4U) { CHECK(!system_status.reset_ready); }
}
CHECK(action_calls == 4U && system_status.reset_busy == 1U && system_status.reset_refused == 1U);
CHECK(system_status.reset_accepted == 1U && system_status.pending_tasks == 0U);
CHECK(system_ack_watch_count() == 0U);
CHECK(IEC104_Slave_Remove_Station(system_slave, &system_stations[0]) == IEC104_STATION_OK);
for (i = 0U; i < 4U; ++i) {
CHECK(IEC104_Slave_Remove_Station(system_slave, &extra[i]) == IEC104_STATION_OK);
}
CHECK(!IEC104_Station_Is_Reusable(&system_stations[0]));
CHECK(IEC104_Station_Is_Reusable(&extra[3]));
for (i = 0U; i < 4U; ++i) {
CHECK(IEC104_SystemCommand_Take_Reset(system_command, &output));
CHECK(output.common_address == i + 1U && output.station_id == ids[i]);
}
CHECK(!IEC104_SystemCommand_Take_Reset(system_command, &output));
for (i = 0U; i < 4U; ++i) { CHECK(IEC104_Station_Is_Reusable(&extra[i])); }
system_close(); ++system_groups;
}
/**
* 功能:验证以下场景与约束:广播第二站提交前到期只将该站改为否定,已ACK首站仍保留。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:显式Cancel则连READY也放弃。
* 错误广播的快照和当前站引用同样必须归还,不能让节点永久不能复用。
*/
static void test_system_broadcast_timeout_and_cancel(void)
{
unsigned mode;
for (mode = 0U; mode < 3U; ++mode) {
IEC104_SystemCommandResetRequest_t output;
system_open(1000U, 100U); system_add_second_station();
if (mode == 2U) {
send_wait_type = 105;
system_broadcast_request(3U); system_flush();
} else {
system_broadcast_request(1U); system_broadcast_execute(); system_flush();
system_ack_all(); CHECK(IEC104_SystemCommand_Process(system_command));
ack_submit_wait = 1; system_broadcast_execute(); system_flush();
}
if (mode == 0U) {
fake.now += 100U; system_flush();
CHECK(system_status.reset_ready && !system_status.ack_pending && !system_status.timer_active);
CHECK(system_status.reset_cancelled == 1U && system_status.ack_timeouts == 1U);
system_broadcast_expect(1U, 2U, 1U, true);
CHECK(IEC104_SystemCommand_Take_Reset(system_command, &output) && output.common_address == 1U);
} else {
IEC104_SystemCommand_Cancel(system_command); system_get_status();
CHECK(system_status.pending_tasks == 0U && !system_status.reset_ready && !system_status.timer_active);
CHECK(system_ack_watch_count() == 0U);
}
CHECK(!IEC104_SystemCommand_Take_Reset(system_command, &output));
CHECK(IEC104_Slave_Remove_Station(system_slave, &system_stations[0]) == IEC104_STATION_OK);
CHECK(IEC104_Slave_Remove_Station(system_slave, &system_stations[1]) == IEC104_STATION_OK);
CHECK(IEC104_Station_Is_Reusable(&system_stations[0]) && IEC104_Station_Is_Reusable(&system_stations[1]));
system_close(); ++system_groups;
}
}
/* [105/PRIVATE] 专用动作由集成方定义。此回调只判许可并核对原QRP/OA/站身份,不执行任何动作。
* PRIVATE默认关闭,测试显式开启后才允许128..255进入此入口,保留值和TEST仍不得进入。 */
static uint8_t system_private_qrp;
/**
* 功能:核对专用QRP、OA及展开后的站点身份,计数后按模式返回许可或拒绝,不执行实际复位。
* 输入参数:context——业务回调的测试上下文;request——当前业务请求(只读)。
* 输出参数:无。
* 返回值:动作回调的接受或拒绝决定。
* 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。
*/
static IEC104_SystemCommandDecision_t system_private_action(void *context,
const IEC104_SystemCommandResetRequest_t *request)
{
CHECK(context == &application_cleared);
CHECK(request->qualifier == system_private_qrp && request->qualifier >= 128U);
CHECK(request->originator_address == 0x29U && request->common_address != IEC104_CA_BROADCAST);
CHECK(request->station_id != 0U && IEC104_Slave_Get_Station_By_Id(system_slave, request->station_id) ==
IEC104_Slave_Get_Station(system_slave, request->common_address));
++action_calls;
return action_mode == 1U || (action_mode == 2U && request->common_address == 1U) ?
IEC104_SYSTEM_COMMAND_DECISION_REJECT : IEC104_SYSTEM_COMMAND_DECISION_ACCEPT;
}
/**
* 功能:设置OA=0x29、目标CA和专用限定词,记录回调期望值后提交原始复位请求。
* 输入参数:qualifier——原始限定词;ca——公共地址。
* 输出参数:无。
* 返回值:无。
* 说明:本辅助入口用于构造或核对上述测试场景,相关状态保存在当前测试夹具中。
*/
static void system_private_request(uint8_t qualifier, uint16_t ca)
{
uint8_t request[10];
memcpy(request, system_reset_request, sizeof(request));
request[3] = 0x29U; request[4] = (uint8_t)ca; request[5] = (uint8_t)(ca >> 8); request[9] = qualifier;
system_private_qrp = qualifier;
system_request(request, sizeof(request));
}
/**
* 功能:将专用动作许可回调交给一次Execute_Next,保留返回值供各类等待与拒绝用例断言。
* 输入参数:无。
* 输出参数:无。
* 返回值:单步执行结果,区分已执行、无任务、等待及错误。
* 说明:本辅助入口用于构造或核对上述测试场景,相关状态保存在当前测试夹具中。
*/
static IEC104_SystemCommandExecuteResult_t system_private_execute(void)
{
return IEC104_SystemCommand_Execute_Next(system_command, system_private_action, &application_cleared);
}
/**
* 功能:按指定COT、CA及专用QRP构造期望确认,逐字节检查固定OA的回显。
* 输入参数:index——待访问或核对的条目下标;qualifier——原始限定词;ca——公共地址;cause——完整传送原因字节。
* 输出参数:无。
* 返回值:无。
* 说明:本辅助入口用于构造或核对上述测试场景,相关状态保存在当前测试夹具中。
*/
static void system_private_expect(unsigned index, uint8_t qualifier, uint8_t ca, uint8_t cause)
{
uint8_t expected[10];
memcpy(expected, system_reset_confirmation, sizeof(expected));
expected[2] = cause; expected[3] = 0x29U; expected[4] = ca; expected[9] = qualifier;
system_expect(index, expected, sizeof(expected));
}
/**
* 功能:验证以下场景与约束:仅启用PRIVATE足以接管105。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:其他RESET功能关闭不放行1/2。默认禁用和保留值否定,合法TEST肯定模拟。
*/
static void test_system_private_validation(void)
{
static const uint8_t qualifiers[] = {0U,3U,127U,1U,2U,128U,192U,255U,128U,255U};
unsigned i;
for (i = 0U; i < sizeof(qualifiers) / sizeof(qualifiers[0]); ++i) {
uint8_t request[10];
system_features = i >= 5U && i <= 7U ? 15U : IEC104_SYSTEM_COMMAND_FEATURE_RESET_PRIVATE;
system_open(100U, 100U);
memcpy(request, system_reset_request, sizeof(request)); request[3] = 0x29U; request[9] = qualifiers[i];
if (i >= 8U) { request[2] |= 0x80U; }
system_request(request, sizeof(request)); system_flush();
CHECK(system_private_execute() == IEC104_SYSTEM_COMMAND_EXECUTE_EMPTY && action_calls == 0U);
system_private_expect(0U, qualifiers[i], 1U, i >= 8U ? 0x87U : 0x47U);
CHECK(!system_status.ack_pending && !system_status.reset_ready && count_calls == 0U && discard_calls == 0U);
system_close(); ++system_groups;
}
system_features = IEC104_SYSTEM_COMMAND_FEATURE_INIT_END;
system_open(100U, 100U); system_private_request(128U, 1U); system_flush();
CHECK(system_handled == IEC104_SYSTEM_COMMAND_EVENT_IGNORED && system_frame_count() == 0U);
CHECK(system_private_execute() == IEC104_SYSTEM_COMMAND_EXECUTE_EMPTY && action_calls == 0U);
system_close(); ++system_groups;
{
IEC104_Slave_t *slave = IEC104_Slave_Create();
IEC104_SystemCommand_t *command;
IEC104_SystemCommandConfig_t config;
CHECK(slave != NULL);
test_system_config(&config);
CHECK(config.features == 0x0fU);
for (i = 5U; i <= 7U; ++i) {
config.features = (uint8_t)(1U << i);
CHECK(IEC104_SystemCommand_Create(slave, &config) == NULL);
}
config.features = IEC104_SYSTEM_COMMAND_FEATURE_RESET_PRIVATE;
command = IEC104_SystemCommand_Create(slave, &config);
CHECK(command != NULL && IEC104_SystemCommand_Destroy(command));
CHECK(IEC104_Slave_Destroy(slave, NULL) == IEC104_TCP_OK);
++system_groups;
}
}
/**
* 功能:验证以下场景与约束:端点和中间值均原样交应用,ACCEPT只预占许可,WAIT不重做。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:原QRP/OA/站身份在Take时保持。
*/
static void test_system_private_decisions(void)
{
static const uint8_t qualifiers[] = {128U,192U,255U};
unsigned i, reject;
for (i = 0U; i < sizeof(qualifiers) / sizeof(qualifiers[0]); ++i) {
for (reject = 0U; reject <= 1U; ++reject) {
IEC104_SystemCommandResetRequest_t output, unchanged;
uint64_t station_id;
system_features = IEC104_SYSTEM_COMMAND_FEATURE_RESET_PRIVATE;
system_open(1000U, 1000U); action_mode = reject;
station_id = IEC104_Station_Get_Id(&system_stations[0]);
system_private_request(qualifiers[i], 1U);
CHECK(system_private_execute() == IEC104_SYSTEM_COMMAND_EXECUTE_OK);
if (reject) { send_wait_type = 105; } else { ack_submit_wait = 1; }
system_flush();
CHECK(action_calls == 1U && system_frame_count() == 0U);
CHECK(system_private_execute() == IEC104_SYSTEM_COMMAND_EXECUTE_EMPTY);
CHECK(application_cleared == 0U && count_calls == 0U && discard_calls == 0U);
memset(&unchanged, 0xa5, sizeof(unchanged)); output = unchanged;
CHECK(!IEC104_SystemCommand_Take_Reset(system_command, &output));
CHECK(memcmp(&output, &unchanged, sizeof(output)) == 0);
send_wait_type = ack_submit_wait = 0; system_flush();
system_private_expect(0U, qualifiers[i], 1U, reject ? 0x47U : 7U);
CHECK(!IEC104_SystemCommand_Take_Reset(system_command, &output));
system_ack_all(); CHECK(IEC104_SystemCommand_Process(system_command)); system_get_status();
CHECK(system_status.reset_ready == (reject == 0U));
if (!reject) {
CHECK(IEC104_SystemCommand_Take_Reset(system_command, &output));
CHECK(output.qualifier == qualifiers[i] && output.originator_address == 0x29U);
CHECK(output.common_address == 1U && output.station_id == station_id);
}
CHECK(!IEC104_SystemCommand_Take_Reset(system_command, &output));
CHECK(action_calls == 1U && system_status.events_cleared_requests == 0U && system_status.events_discarded == 0U);
system_close(); ++system_groups;
}
}
}
/**
* 功能:验证以下场景与约束:复用决定/ACK期限和会话边界:提交前过期否定。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:已提交超时不撤回;Cancel主动放弃;STOP仅保留已ACK。
*/
static void test_system_private_deadlines_and_cancel(void)
{
unsigned mode;
for (mode = 0U; mode < 7U; ++mode) {
IEC104_SystemCommandResetRequest_t output;
system_features = IEC104_SYSTEM_COMMAND_FEATURE_RESET_PRIVATE;
system_open(100U, 100U); system_private_request(255U, 1U);
if (mode == 0U) { fake.now += 100U; }
CHECK(system_private_execute() == IEC104_SYSTEM_COMMAND_EXECUTE_OK);
if (mode == 1U) { ack_submit_wait = 1; }
system_flush();
CHECK(action_calls == (mode == 0U ? 0U : 1U));
if (mode == 1U || mode == 2U) { fake.now += 100U; system_flush(); }
else if (mode == 3U) { IEC104_SystemCommand_Cancel(system_command); }
else if (mode >= 4U) {
if (mode >= 5U) { system_ack_all(); }
if (mode == 6U) {
CHECK(IEC104_SystemCommand_Process(system_command));
IEC104_SystemCommand_Cancel(system_command);
} else { push(stop_act, sizeof(stop_act)); system_poll(); }
}
system_get_status();
CHECK(system_status.reset_ready == (mode == 5U));
if (mode == 5U) {
CHECK(IEC104_SystemCommand_Take_Reset(system_command, &output));
CHECK(output.qualifier == 255U && output.common_address == 1U && output.originator_address == 0x29U);
}
CHECK(!IEC104_SystemCommand_Take_Reset(system_command, &output));
CHECK(count_calls == 0U && discard_calls == 0U && application_cleared == 0U);
system_private_expect(0U, 255U, 1U, mode <= 1U ? 0x47U : 7U);
CHECK(system_frame_count() == 1U && system_ack_watch_count() == 0U);
system_close(); ++system_groups;
}
}
/**
* 功能:验证以下场景与约束:私有授权占同一全局忙状态。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:新请求不能覆盖前条原QRP。即使已有待发CP56事件也绝不触碰清除接口。
*/
static void test_system_private_busy_and_no_clear(void)
{
IEC104_SystemCommandResetRequest_t output;
uint32_t count;
system_features = IEC104_SYSTEM_COMMAND_FEATURE_RESET_PRIVATE;
system_open(1000U, 1000U);
system_private_request(128U, 1U); CHECK(system_private_execute() == IEC104_SYSTEM_COMMAND_EXECUTE_OK); system_flush();
system_private_request(255U, 1U); CHECK(system_private_execute() == IEC104_SYSTEM_COMMAND_EXECUTE_OK); system_flush();
system_private_expect(0U, 128U, 1U, 7U); system_private_expect(1U, 255U, 1U, 0x47U);
CHECK(action_calls == 1U && system_status.reset_busy == 1U);
system_ack_all(); CHECK(IEC104_SystemCommand_Process(system_command));
CHECK(IEC104_SystemCommand_Take_Reset(system_command, &output) && output.qualifier == 128U);
system_close(); ++system_groups;
system_features = IEC104_SYSTEM_COMMAND_FEATURE_RESET_PRIVATE | IEC104_SYSTEM_COMMAND_FEATURE_TEST_COMMAND;
system_window = 1U; system_open(1000U, 1000U);
system_request(system_test_request, sizeof(system_test_request)); system_flush(); /* 阻塞窗口,使事件保持未提交。 */
system_enqueue(1U, true); system_enqueue(2U, true);
system_private_request(192U, 1U); CHECK(system_private_execute() == IEC104_SYSTEM_COMMAND_EXECUTE_OK);
CHECK(IEC104_Slave_Count_Pending_Events(system_slave, 1U, IEC104_SLAVE_EVENTS_TIME_TAGGED, &count, NULL) == IEC104_TCP_OK);
CHECK(count == 1U);
CHECK(IEC104_Slave_Count_Pending_Events(system_slave, 2U, IEC104_SLAVE_EVENTS_TIME_TAGGED, &count, NULL) == IEC104_TCP_OK);
CHECK(count == 1U && action_calls == 1U && count_calls == 0U && discard_calls == 0U && application_cleared == 0U);
system_close(); ++system_groups;
}
/**
* 功能:验证以下场景与约束:私有广播保留原QRP/OA,但逐站使用具体CA。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:默认单观察槽也必须完成整批屏障,首站拒绝不影响后站。
*/
static void test_system_private_broadcast(void)
{
unsigned mode;
for (mode = 0U; mode < 2U; ++mode) {
IEC104_SystemCommandResetRequest_t output;
uint8_t qrp = mode == 0U ? 128U : 255U;
system_features = IEC104_SYSTEM_COMMAND_FEATURE_RESET_PRIVATE;
system_open(1000U, 0U); system_add_second_station(); action_mode = mode == 0U ? 0U : 2U;
system_private_request(qrp, IEC104_CA_BROADCAST);
CHECK(system_private_execute() == IEC104_SYSTEM_COMMAND_EXECUTE_OK); system_flush();
system_private_expect(0U, qrp, 1U, mode == 0U ? 7U : 0x47U);
system_ack_all(); CHECK(IEC104_SystemCommand_Process(system_command)); system_get_status();
CHECK(!system_status.reset_ready && !IEC104_SystemCommand_Take_Reset(system_command, &output));
CHECK(system_private_execute() == IEC104_SYSTEM_COMMAND_EXECUTE_OK); system_flush();
system_private_expect(1U, qrp, 2U, 7U);
CHECK(!IEC104_SystemCommand_Take_Reset(system_command, &output));
system_ack_all(); CHECK(IEC104_SystemCommand_Process(system_command)); system_get_status();
CHECK(system_status.reset_ready && system_status.reset_accepted == 1U && action_calls == 2U);
if (mode == 0U) {
CHECK(IEC104_SystemCommand_Take_Reset(system_command, &output));
CHECK(output.qualifier == qrp && output.originator_address == 0x29U && output.common_address == 1U);
}
CHECK(IEC104_SystemCommand_Take_Reset(system_command, &output));
CHECK(output.qualifier == qrp && output.originator_address == 0x29U && output.common_address == 2U);
CHECK(!IEC104_SystemCommand_Take_Reset(system_command, &output));
CHECK(count_calls == 0U && discard_calls == 0U && application_cleared == 0U);
system_close(); ++system_groups;
}
}
/**
* 功能:[105/TEST] T位属于请求语义,不等于Type107。
* 输入参数:qrp——复位进程限定词;ca——公共地址。
* 输出参数:无。
* 返回值:无。
* 说明:合法105 TEST只走普通回复,
* 即使应用决定/ACK期限经过、主站确认或会话结束,也不能产生真实许可或副作用。
*/
static void system_test_reset_request(uint8_t qrp, uint16_t ca)
{
uint8_t request[10];
memcpy(request, system_reset_request, sizeof(request));
request[2] |= 0x80U; request[3] = 0x29U;
request[4] = (uint8_t)ca; request[5] = (uint8_t)(ca >> 8); request[9] = qrp;
system_request(request, sizeof(request));
}
/**
* 功能:验证以下场景与约束:标准QRP1/2和启用后的专用端点/中间值均模拟成功。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:广播按原快照顺序逐站肯定。
* 原QRP/OA/T逐字节保持,提交WAIT重试始终不会转入action,也不占用ACK观察槽。
*/
static void test_system_test_reset_service(void)
{
static const uint8_t qualifiers[] = {1U,2U,128U,192U,255U};
unsigned i, broadcast;
for (i = 0U; i < sizeof(qualifiers) / sizeof(qualifiers[0]); ++i) {
for (broadcast = 0U; broadcast <= 1U; ++broadcast) {
IEC104_SystemCommandResetRequest_t output, unchanged;
system_features = 15U | IEC104_SYSTEM_COMMAND_FEATURE_RESET_PRIVATE;
system_open(100U, 100U);
if (broadcast) { system_add_second_station(); }
send_wait_type = 105;
system_test_reset_request(qualifiers[i], broadcast ? IEC104_CA_BROADCAST : 1U);
CHECK(system_execute() == IEC104_SYSTEM_COMMAND_EXECUTE_EMPTY);
system_flush();
CHECK(!system_status.decide_pending && !system_status.ack_pending && !system_status.reset_ready);
CHECK(system_status.send_waiting && !system_status.need_process && !system_status.timer_active);
CHECK(system_frame_count() == 0U && system_ack_watch_count() == 0U);
fake.now += 200U; system_flush();
CHECK(system_status.timeouts == 0U && system_status.ack_timeouts == 0U);
CHECK(action_calls == 0U && application_cleared == 0U && count_calls == 0U && discard_calls == 0U);
memset(&unchanged, 0xa5, sizeof(unchanged)); output = unchanged;
CHECK(!IEC104_SystemCommand_Take_Reset(system_command, &output));
CHECK(memcmp(&output, &unchanged, sizeof(output)) == 0);
send_wait_type = 0; system_flush();
system_private_expect(0U, qualifiers[i], 1U, 0x87U);
if (broadcast) { system_private_expect(1U, qualifiers[i], 2U, 0x87U); }
CHECK(system_frame_count() == broadcast + 1U && system_status.pending_tasks == 0U);
CHECK(system_status.reset_accepted == 1U && system_status.negative_submitted == 0U);
system_ack_all(); CHECK(IEC104_SystemCommand_Process(system_command)); system_get_status();
CHECK(system_ack_watch_count() == 0U && !system_status.reset_ready && !system_status.ack_pending);
CHECK(!IEC104_SystemCommand_Take_Reset(system_command, &output));
if (broadcast) { fake.recv_eof = 1U; } else { push(stop_act, sizeof(stop_act)); }
system_poll(); system_get_status();
CHECK(!system_status.reset_ready && !IEC104_SystemCommand_Take_Reset(system_command, &output));
CHECK(system_status.resets_released == 0U && system_status.reset_cancelled == 0U);
CHECK(action_calls == 0U && count_calls == 0U && discard_calls == 0U);
system_close(); ++system_groups;
}
}
}
/**
* 功能:验证以下场景与约束:TEST仍受范围/功能位约束。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:不会把未支持QRP借测试模式放行,广播否定也保留T和实际CA。
*/
static void test_system_test_reset_invalid(void)
{
static const uint8_t qualifiers[] = {0U,3U,127U,128U,255U,1U,2U};
unsigned i, broadcast;
for (i = 0U; i < sizeof(qualifiers) / sizeof(qualifiers[0]); ++i) {
for (broadcast = 0U; broadcast <= 1U; ++broadcast) {
IEC104_SystemCommandResetRequest_t output;
system_features = i <= 2U || i >= 5U ? IEC104_SYSTEM_COMMAND_FEATURE_RESET_PRIVATE : 15U;
system_open(100U, 100U);
if (broadcast) { system_add_second_station(); }
system_test_reset_request(qualifiers[i], broadcast ? IEC104_CA_BROADCAST : 1U); system_flush();
system_private_expect(0U, qualifiers[i], 1U, 0xc7U);
if (broadcast) { system_private_expect(1U, qualifiers[i], 2U, 0xc7U); }
CHECK(system_execute() == IEC104_SYSTEM_COMMAND_EXECUTE_EMPTY && action_calls == 0U);
CHECK(system_status.rejected == 1U && system_status.reset_accepted == 0U);
CHECK(!system_status.reset_ready && system_ack_watch_count() == 0U);
CHECK(!IEC104_SystemCommand_Take_Reset(system_command, &output));
system_close(); ++system_groups;
}
}
}
/**
* 功能:验证以下场景与约束:k窗口先被107占满,使CP56原文稳定留在NORMAL。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:TEST广播QRP2不能借普通动作清除这些事件。
*/
static void test_system_test_reset_keeps_events(void)
{
static const uint8_t qualifiers[] = {1U,2U,128U};
unsigned i;
for (i = 0U; i < sizeof(qualifiers) / sizeof(qualifiers[0]); ++i) {
uint32_t count;
IEC104_SystemCommandResetRequest_t output;
system_features = 15U | IEC104_SYSTEM_COMMAND_FEATURE_RESET_PRIVATE;
system_window = 1U; system_open(100U, 100U); system_add_second_station();
system_request(system_test_request, sizeof(system_test_request)); system_flush();
system_enqueue(1U, true); system_enqueue(2U, true);
system_test_reset_request(qualifiers[i], IEC104_CA_BROADCAST); system_flush();
CHECK(IEC104_Slave_Count_Pending_Events(system_slave, 1U, IEC104_SLAVE_EVENTS_TIME_TAGGED, &count, NULL) == IEC104_TCP_OK);
CHECK(count == 1U);
CHECK(IEC104_Slave_Count_Pending_Events(system_slave, 2U, IEC104_SLAVE_EVENTS_TIME_TAGGED, &count, NULL) == IEC104_TCP_OK);
CHECK(count == 1U && action_calls == 0U && application_cleared == 0U && count_calls == 0U && discard_calls == 0U);
CHECK(!IEC104_SystemCommand_Take_Reset(system_command, &output));
system_close(); ++system_groups;
}
}
/**
* 功能:验证以下场景与约束:已确定的真实许可与TEST完全独立:TEST不受复位busy影响,不覆盖原QRP/OA,也不能再领取一次。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:此时唯一ACK观察槽仍属于原真实请求;测试帧通过普通发送路径,不申请第二个槽。
*/
static void test_system_test_reset_keeps_real_authority(void)
{
IEC104_SystemCommandResetRequest_t output;
IEC104_SlaveEventIdentity_t identity;
uint64_t station_id;
system_features = 15U | IEC104_SYSTEM_COMMAND_FEATURE_RESET_PRIVATE;
system_prepare_reset(1000U, &identity);
station_id = IEC104_Station_Get_Id(&system_stations[0]);
system_ack_all(); CHECK(IEC104_SystemCommand_Process(system_command)); system_get_status();
CHECK(system_status.reset_ready && system_ack_watch_count() == 1U && action_calls == 1U);
system_test_reset_request(255U, 1U); system_flush();
system_private_expect(1U, 255U, 1U, 0x87U);
CHECK(system_status.reset_ready && system_status.reset_busy == 0U && action_calls == 1U);
CHECK(system_ack_watch_count() == 1U && system_execute() == IEC104_SYSTEM_COMMAND_EXECUTE_EMPTY);
system_ack_all(); CHECK(IEC104_SystemCommand_Process(system_command));
CHECK(IEC104_SystemCommand_Take_Reset(system_command, &output));
system_expect_reset_identity(&output, &identity, station_id);
CHECK(!IEC104_SystemCommand_Take_Reset(system_command, &output));
CHECK(system_ack_watch_count() == 0U);
system_get_status(); CHECK(system_status.resets_released == 1U && system_status.reset_cancelled == 0U);
system_close(); ++system_groups;
}
/**
* 功能:[ENTRY] 槽容量相关场景由各测试内部条件决定是否适用。
* 输入参数:无。
* 输出参数:无。
* 返回值:正常完成返回 0;参数、运行或断言失败以非零状态结束进程。
* 说明:组数以最终输出为准。
*/
int main(void)
{
/* [RUN/104] 无时标测试命令及104/107共用功能位,不改后续历史用例顺序。 */
test_system_104_validation();
test_system_test_feature();
test_system_104_wait();
test_system_104_mixed_fifo();
test_system_104_capacity();
test_system_104_session();
/* [RUN/VALIDATION] 保持107、105、70的历史执行顺序,分别检查回显、拒绝和初始化。 */
test_system_107_validation();
test_system_107_auxiliary_fields();
test_system_105_validation();
test_system_init_rounds();
test_system_init_pending_and_wait();
test_system_init_completion_handoff();
test_system_init_completion_restart();
/* [RUN/RESET] 决定、ACK、取消及会话边界;授权交出与实际设备复位是两个阶段。 */
test_system_decisions();
test_system_ack_deadlines();
test_system_reset_pending_timeout();
test_system_reset_pending_timeout_cleanup();
test_system_reset_order_and_cancel();
test_system_reset_session_boundaries();
test_system_reset_ack_stop_order();
test_system_reset_stop_deadlines();
test_system_reset_commit_reconnect();
test_system_reset_service_close();
test_system_ack_errors_and_busy();
test_system_broadcast_reset_barrier(1000U);
test_system_broadcast_reset_barrier(0U);
test_system_broadcast_reset_decisions_and_stop();
test_system_broadcast_clear_and_snapshot();
test_system_broadcast_invalid_and_empty();
test_system_broadcast_reset_capacity();
test_system_broadcast_timeout_and_cancel();
test_system_private_validation();
test_system_private_decisions();
test_system_private_deadlines_and_cancel();
test_system_private_busy_and_no_clear();
test_system_private_broadcast();
test_system_test_reset_service();
test_system_test_reset_invalid();
test_system_test_reset_keeps_events();
test_system_test_reset_keeps_real_authority();
/* [RUN/FAILURES] 交接错误、QRP2副作用范围及实例回收。 */
test_system_submission_failures();
test_system_clear_results();
test_system_clear_ca_and_station();
test_system_lifetime_and_capacity();
printf("SystemCommand tests: %u groups passed (TCP=%u tasks=%u)\n", system_groups,
(unsigned)IEC104_TCP_SERVER_CAPACITY, (unsigned)IEC104_SYSTEM_COMMAND_TASK_CAPACITY);
return 0;
}