/* * 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; }