2678 lines
138 KiB
C
2678 lines
138 KiB
C
/*
|
||
* 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;
|
||
}
|