6318 lines
324 KiB
C
6318 lines
324 KiB
C
/*
|
||
* IEC104遥控业务回归:通过真实Slave、TCP及SendManager路径验证控制事务。
|
||
* 复用iec104_tcp_fixture.h的可控Net、单调时钟和收发缓冲。
|
||
* 输入及期望应答由字节手工构造,避免输入与被测编码器共享同一种错误。
|
||
* 本文件已间接包含TcpServer.c,构建时不得再链接TcpServer.c或平台Net后端。
|
||
* 同一组用例分别运行于TCP容量1/2、独立应答槽容量1/4,输出用例组数与公开结构尺寸。
|
||
*/
|
||
/*
|
||
* 文件内导航(搜索方括号标记;Suite:Command):
|
||
* 复用公共fake Net和真实Slave/TCP;command_*为本专项辅助,TEST_HOOKS用于查询/凭证故障注入。
|
||
* [COMMON/BASE] 公共基础:依赖、编译选项与断言入口
|
||
* [COMMAND/FIXTURE_STATE] 专属夹具状态:服务、站点、事务、模拟动作及窗口
|
||
* [COMMAND/HOOKS] 测试钩子:状态查询与应答凭证故障注入
|
||
* [COMMON/LIFECYCLE] 专项共用辅助:点配置、服务启停、通知和业务事件消费
|
||
* [COMMON/WIRE] 专项共用辅助:独立请求字节、发送、回显及帧计数
|
||
* [COMMON/TRANSACTION] 专项共用辅助:动作、选择/执行、返回信息、完成、拥塞与重入
|
||
* [COMMAND/BASE] 基础事务用例:配置、报文、完整流程、动作结果及忙匹配
|
||
* [COMMAND/DUPLICATE] 决定期间重复请求:非选择重发、期限、校验和身份边界
|
||
* [COMMAND/LIFETIME] 事务生命周期:FINISHED、撤销、期限、FIFO、会话和站点
|
||
* [COMMAND/EXTENDED_HELPERS] 扩展命令辅助:47–51的值、原文请求与回显
|
||
* [COMMAND/EXTENDED] 扩展命令用例:类型配置、流程、匹配、非法值与变长回复
|
||
* [COMMAND/TIMED_HELPERS] 带时标辅助:58–64请求及CP56/基准配置
|
||
* [COMMAND/QUALIFIERS] QU/QL边界及非法限定词与既有事务隔离
|
||
* [COMMAND/TIMED] 带时标用例:完整流程、UTC换算、时间窗、基准与重入
|
||
* [COMMAND/POINTS] 点表用例:默认掩码、空表、逐点模式、二分查点及身份
|
||
* [COMMAND/RETURNS] 应答收尾用例:持续突发、返回信息与交接寿命
|
||
* [COMMAND/ADMISSION] 动作前准入:HIGH余量、旧回复门禁与查询失败
|
||
* [COMMAND/COMPLETION] 完成期限:Complete、交接超时、优先级与ENDED回收
|
||
* [COMMAND/ACTION_TIME] 动作前时效:等待中过期、拒绝原因及凭证故障
|
||
* [COMMAND/ABNORMAL] 异常收尾:失败/超时否定TERM、期限及会话边界
|
||
* [COMMAND/RESELECT] 重复选择复归:旧许可失效、清理事件与必要否定的FIFO
|
||
* [COMMAND/ADDRESS] 撤销寻址:未知IOA、错误优先级、事务隔离与应答背压
|
||
* [ENTRY/MAIN] 测试入口:基础、扩展、时标、点表及收尾分组
|
||
* 公共事务区集中动作与重入探针;扩展/时标辅助区包含独立输入表和各自的构造、校验函数。
|
||
* 函数定义按主题归类;main保留原调用顺序,RUN/CASE标记细分执行组。
|
||
*/
|
||
|
||
/* ============================================================================
|
||
* [COMMON/BASE] 公共基础:依赖、编译选项与断言入口
|
||
* ============================================================================ */
|
||
#include "iec104_test_config.h"
|
||
#include "iec104_tcp_fixture.h"
|
||
#include "IEC104_Command.h"
|
||
|
||
#ifndef IEC104_COMMAND_REPLY_CAPACITY
|
||
#define IEC104_COMMAND_REPLY_CAPACITY 4U
|
||
#endif
|
||
|
||
/* ============================================================================
|
||
* [COMMAND/FIXTURE_STATE] 专属夹具状态:服务、站点、事务、模拟动作及窗口
|
||
* ============================================================================ */
|
||
/* 每个用例独占一套服务、业务实例和站点;open/close负责隔离上一轮状态。
|
||
* last_input保留修复自引用后的真实Slave事件,供构造发送拥塞或重入校验使用。
|
||
* action_result控制模拟动作结果,action_calls和action_request核对至多一次执行及参数。
|
||
* window只在窗口背压用例中缩小,close恢复默认值,防止影响下一组测试。 */
|
||
static IEC104_Slave_t *command_slave;
|
||
static IEC104_Command_t *command;
|
||
static IEC104_Station_t command_station;
|
||
static IEC104_CommandStatus_t command_status;
|
||
static IEC104_SlaveEvent_t command_last_input;
|
||
static IEC104_CommandEventResult_t command_last_handled;
|
||
static unsigned command_master_ns, command_action_calls, command_checks;
|
||
static IEC104_CommandActionResult_t command_action_result;
|
||
static IEC104_CommandRequest_t command_action_request;
|
||
static uint16_t command_window = 32U;
|
||
|
||
/* ============================================================================
|
||
* [COMMAND/HOOKS] 测试钩子:状态查询与应答凭证故障注入
|
||
* ============================================================================ */
|
||
#ifdef IEC104_COMMAND_TEST_HOOKS
|
||
/* Faults are injected at Command's query boundaries.
|
||
* The transport, queue and default Slave implementations remain real. */
|
||
static bool command_response_error;
|
||
/* 0走真实查询,1使查询返回失败,2让查询成功但队列统计无效。
|
||
* 两类故障都应拒绝动作,而不是当作单纯容量不足继续等待。 */
|
||
static unsigned command_capacity_fault;
|
||
/**
|
||
* 功能:只让凭证查询返回故障,已有发送记录保持真实,用来检查故障能否终结事务且保留动作事实。
|
||
* 输入参数:slave——被测 Slave 实例(只读);ticket——发送跟踪票据。
|
||
* 输出参数:无。
|
||
* 返回值:响应票据状态,保留待交接、已交接及失效等区别。
|
||
* 说明:本辅助入口用于构造或核对上述测试场景,相关状态保存在当前测试夹具中。
|
||
*/
|
||
IEC104_ResponseState_t IEC104_Command_Test_Response_State(const IEC104_Slave_t *slave, uint64_t ticket)
|
||
{
|
||
return command_response_error ? IEC104_RESPONSE_ERROR : IEC104_Slave_Get_Response_State(slave, ticket);
|
||
}
|
||
/**
|
||
* 功能:区分查询调用失败与队列统计不可用。
|
||
* 输入参数:slave——被测 Slave 实例(只读);status——状态快照;error——底层错误码存储。
|
||
* 输出参数:status——状态快照;error——底层错误码存储。
|
||
* 返回值:真实传输接口或故障注入产生的 TCP 操作结果。
|
||
* 说明:两者都不能被当作HIGH还有容量而继续动作。
|
||
*/
|
||
IEC104_TcpResult_t IEC104_Command_Test_Get_Status(const IEC104_Slave_t *slave,
|
||
IEC104_TcpServerStatus_t *status, IEC104_TcpError_t *error)
|
||
{
|
||
IEC104_TcpResult_t result;
|
||
if (command_capacity_fault == 1U) { return IEC104_TCP_INTERNAL_ERROR; }
|
||
result = IEC104_Slave_Get_Status(slave, status, error);
|
||
if (result == IEC104_TCP_OK && command_capacity_fault == 2U) { status->asdu_queue_status_valid = false; }
|
||
return result;
|
||
}
|
||
#endif
|
||
|
||
/* These immutable tables belong to the test fixture, not the library defaults.
|
||
* Keep all borrowed point storage alive until the corresponding Destroy. */
|
||
static const IEC104_CommandPoint_t command_select_points[] = {
|
||
{1U, 6001U, UINT16_C(0x1fbf), IEC104_COMMAND_MODE_SELECT_EXECUTE},
|
||
{1U, 6002U, UINT16_C(0x1fbf), IEC104_COMMAND_MODE_SELECT_EXECUTE},
|
||
{2U, 6001U, UINT16_C(0x1fbf), IEC104_COMMAND_MODE_SELECT_EXECUTE}
|
||
};
|
||
static const IEC104_CommandPoint_t command_direct_points[] = {
|
||
{1U, 6001U, UINT16_C(0x3fff), IEC104_COMMAND_MODE_DIRECT},
|
||
{1U, 6002U, UINT16_C(0x3fff), IEC104_COMMAND_MODE_DIRECT},
|
||
{2U, 6001U, UINT16_C(0x3fff), IEC104_COMMAND_MODE_DIRECT}
|
||
};
|
||
|
||
/* ============================================================================
|
||
* [COMMON/LIFECYCLE] 专项共用辅助:点配置、服务启停、通知和业务事件消费
|
||
* ============================================================================ */
|
||
/**
|
||
* 功能:给配置借出固定寿命的点表。
|
||
* 输入参数:config——测试配置对象;mode——用例选择的行为模式。
|
||
* 输出参数:config——测试配置对象。
|
||
* 返回值:无。
|
||
* 说明:模式选择只影响该配置,不修改库的默认配置或静态表。
|
||
*/
|
||
static void command_config_mode(IEC104_CommandConfig_t *config, IEC104_CommandMode_t mode)
|
||
{
|
||
config->points = mode == IEC104_COMMAND_MODE_DIRECT ? command_direct_points : command_select_points;
|
||
config->point_count = sizeof(command_select_points) / sizeof(command_select_points[0]);
|
||
}
|
||
|
||
/**
|
||
* 功能:在真实默认配置上显式接入测试用选择执行点表,其他时限、回复策略保持默认值。
|
||
* 输入参数:config——测试配置对象。
|
||
* 输出参数:config——测试配置对象。
|
||
* 返回值:无。
|
||
* 说明:本辅助入口用于构造或核对上述测试场景,相关状态保存在当前测试夹具中。
|
||
*/
|
||
static void command_config_default(IEC104_CommandConfig_t *config)
|
||
{
|
||
IEC104_Command_Config_Default(config);
|
||
command_config_mode(config, IEC104_COMMAND_MODE_SELECT_EXECUTE);
|
||
}
|
||
|
||
/**
|
||
* 功能:消费全部Slave通知并按原FIFO交给Command,不在此消费业务事件或执行应用动作。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:last_handled只记录最近一条I帧的分派结果,后续RECORD/启停通知不得覆盖它。
|
||
* 用于验证“先读空通知,再推进动作”的接入约定。
|
||
*/
|
||
static void command_drain_transport(void)
|
||
{
|
||
IEC104_SlaveEvent_t event;
|
||
IEC104_TcpEventResult_t result;
|
||
while ((result = IEC104_Slave_NextEvent(command_slave, &event)) == IEC104_TCP_EVENT_READY) {
|
||
IEC104_CommandEventResult_t handled;
|
||
if (event.transport.type == IEC104_TCP_EVENT_I_FRAME) {
|
||
CHECK(IEC104_Slave_Copy_Event(&command_last_input, &event));
|
||
}
|
||
handled = IEC104_Command_Handle_Event(command, &event);
|
||
CHECK(handled != IEC104_COMMAND_EVENT_ERROR);
|
||
if (event.transport.type == IEC104_TCP_EVENT_I_FRAME) { command_last_handled = handled; }
|
||
}
|
||
CHECK(result == IEC104_TCP_EVENT_EMPTY);
|
||
}
|
||
|
||
/**
|
||
* 功能:推进一次真实传输层并读空通知。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:等待参数为0,可控后端不会真实阻塞。
|
||
*/
|
||
static void command_poll(void)
|
||
{
|
||
CHECK(IEC104_Slave_Poll(command_slave, 0U, NULL) == IEC104_TCP_OK);
|
||
command_drain_transport();
|
||
}
|
||
|
||
/**
|
||
* 功能:推进一步业务并刷新只读状态。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:等待或已正常终结也必须返回处理成功。
|
||
*/
|
||
static void command_process(void)
|
||
{
|
||
CHECK(IEC104_Command_Process(command));
|
||
CHECK(IEC104_Command_Get_Status(command, &command_status));
|
||
}
|
||
|
||
/**
|
||
* 功能:有界交替驱动传输与业务,使已就绪应答交接、写出及通知消费能够完成。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:不自动Accept、不读取FINISHED,也不伪造主站ACK;仍然等待的事务由各用例显式处理。
|
||
*/
|
||
static void command_flush(void)
|
||
{
|
||
unsigned index;
|
||
for (index = 0U; index < 16U; ++index) {
|
||
command_poll();
|
||
command_process();
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 功能:经可控accept和真实STARTDT建立新会话,核对Command收到激活通知。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:新TCP会话的主站发送序号从0开始;事务及旧事件身份由业务模块自行隔离。
|
||
*/
|
||
static void command_connect(void)
|
||
{
|
||
fake.accept_pending = 1U;
|
||
command_poll();
|
||
push(start_act, sizeof(start_act));
|
||
command_poll();
|
||
CHECK(IEC104_Command_Get_Status(command, &command_status));
|
||
CHECK(command_status.active);
|
||
command_master_ns = 0U;
|
||
}
|
||
|
||
/**
|
||
* 功能:创建并激活测试服务,configuration为NULL时使用默认参数及显式测试点表。
|
||
* 输入参数:configuration——可选测试配置(只读)。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:链路和本地发送期限刻意放宽,使业务期限测试不会先触发无关的传输超时。
|
||
* 查找内部TCP实例仅用于现有夹具的容量背压和故障注入,不替换公开收发入口。
|
||
*/
|
||
static void command_open(const IEC104_CommandConfig_t *configuration)
|
||
{
|
||
IEC104_SlaveConfig_t server_configuration;
|
||
IEC104_CommandConfig_t defaults;
|
||
unsigned slot;
|
||
memset(&fake, 0, sizeof(fake));
|
||
memset(&command_station, 0, sizeof(command_station));
|
||
memset(&command_last_input, 0, sizeof(command_last_input));
|
||
fake.now = 1000U;
|
||
command_action_calls = 0U;
|
||
command_action_result = IEC104_COMMAND_ACTION_STARTED;
|
||
#ifdef IEC104_COMMAND_TEST_HOOKS
|
||
command_response_error = false;
|
||
command_capacity_fault = 0U;
|
||
#endif
|
||
command_slave = IEC104_Slave_Create();
|
||
CHECK(command_slave != NULL);
|
||
test_transport_config(&server_configuration);
|
||
server_configuration.protocol.link.k = command_window;
|
||
server_configuration.protocol.link.t1_ms = 600000U;
|
||
server_configuration.protocol.link.t3_ms = 600000U;
|
||
server_configuration.protocol.local_send_timeout_ms = 600000U;
|
||
CHECK(IEC104_Slave_Init(command_slave, &server_configuration, NULL) == IEC104_TCP_OK);
|
||
CHECK(IEC104_Slave_Add_Station(command_slave, &command_station, 1U, &command_action_calls) == IEC104_STATION_OK);
|
||
command_config_default(&defaults);
|
||
command = IEC104_Command_Create(command_slave, configuration == NULL ? &defaults : configuration);
|
||
CHECK(command != NULL);
|
||
sut = NULL;
|
||
for (slot = 0U; slot < IEC104_TCP_SERVER_CAPACITY; ++slot) {
|
||
if (server_pool[slot].in_use) { sut = &server_pool[slot].server; break; }
|
||
}
|
||
CHECK(sut != NULL);
|
||
command_connect();
|
||
}
|
||
|
||
/**
|
||
* 功能:读取且核对恰好一个指定类型的业务事件,返回可跨循环保存的纯值副本。
|
||
* 输入参数:type——协议类型或期望事件类型。
|
||
* 输出参数:无。
|
||
* 返回值:已构造或取出的事件值副本。
|
||
* 说明:调用后事件才算已交付,后续是否欠应用FINISHED以此为界。
|
||
*/
|
||
static IEC104_CommandEvent_t command_take(IEC104_CommandEventType_t type)
|
||
{
|
||
IEC104_CommandEvent_t event;
|
||
memset(&event, 0, sizeof(event));
|
||
CHECK(IEC104_Command_NextEvent(command, &event) == IEC104_COMMAND_NEXT_READY);
|
||
CHECK(event.type == type);
|
||
return event;
|
||
}
|
||
|
||
/**
|
||
* 功能:核对业务队列确实为空,并验证EMPTY不改写调用方输出存储的接口契约。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。
|
||
*/
|
||
static void command_empty(void)
|
||
{
|
||
IEC104_CommandEvent_t event, before;
|
||
memset(&event, 0x5a, sizeof(event));
|
||
before = event;
|
||
CHECK(IEC104_Command_NextEvent(command, &event) == IEC104_COMMAND_NEXT_EMPTY);
|
||
CHECK(memcmp(&event, &before, sizeof(event)) == 0);
|
||
}
|
||
|
||
/**
|
||
* 功能:按Cancel、读完FINISHED、关闭服务、读空通知、Destroy、移除站点的顺序收尾。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:节点必须已可复用,才能销毁Slave;此处不替应用归还额外Acquire的引用。
|
||
*/
|
||
static void command_close(void)
|
||
{
|
||
IEC104_CommandEvent_t event;
|
||
IEC104_CommandNextResult_t result;
|
||
IEC104_Command_Cancel(command);
|
||
while ((result = IEC104_Command_NextEvent(command, &event)) == IEC104_COMMAND_NEXT_READY) {
|
||
CHECK(event.type == IEC104_COMMAND_FINISHED);
|
||
}
|
||
CHECK(result == IEC104_COMMAND_NEXT_EMPTY);
|
||
CHECK(IEC104_Slave_Close(command_slave, NULL) == IEC104_TCP_OK);
|
||
command_drain_transport();
|
||
CHECK(IEC104_Command_Destroy(command));
|
||
if (IEC104_Station_Is_Registered(&command_station)) {
|
||
CHECK(IEC104_Slave_Remove_Station(command_slave, &command_station) == IEC104_STATION_OK);
|
||
}
|
||
CHECK(IEC104_Station_Is_Reusable(&command_station));
|
||
CHECK(IEC104_Slave_Destroy(command_slave, NULL) == IEC104_TCP_OK);
|
||
command = NULL;
|
||
command_slave = NULL;
|
||
command_window = 32U;
|
||
}
|
||
|
||
/* ============================================================================
|
||
* [COMMON/WIRE] 专项共用辅助:独立请求字节、发送、回显及帧计数
|
||
* ============================================================================ */
|
||
/**
|
||
* 功能:将调用方提供的ASDU字节封装成主站I帧,维护主站N(S),不自动确认子站数据。
|
||
* 输入参数:payload——原始对象载荷(只读);length——字节长度。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:只写入可控Net输入队列;何时接收、交付和推进业务由用例决定。
|
||
*/
|
||
static void command_queue(const uint8_t *payload, size_t length)
|
||
{
|
||
uint8_t frame[255] = {0x68};
|
||
CHECK(length <= 249U);
|
||
frame[1] = (uint8_t)(length + 4U);
|
||
frame[2] = (uint8_t)(command_master_ns << 1);
|
||
frame[3] = (uint8_t)(command_master_ns >> 7);
|
||
++command_master_ns;
|
||
memcpy(frame + 6U, payload, length);
|
||
push(frame, length + 6U);
|
||
}
|
||
|
||
/**
|
||
* 功能:手工生成固定10字节的45/46请求或等长监视对象,用于输入和独立的期望结果。
|
||
* 输入参数:bytes——报文字节缓冲区;type——协议类型或期望事件类型;cause——完整传送原因字节;oa——发起者地址;ca——公共地址;ioa——信息对象地址;value——测试对象值或原始位模式。
|
||
* 输出参数:bytes——写入或读出的数据字节。
|
||
* 返回值:无。
|
||
* 说明:cause包含完整COT字节(包括TEST/P/N),value保留原SCO/DCO或监视对象字节。
|
||
*/
|
||
static void command_bytes(uint8_t bytes[10], unsigned type, unsigned cause,
|
||
unsigned oa, unsigned ca, unsigned ioa, unsigned value)
|
||
{
|
||
bytes[0] = (uint8_t)type; bytes[1] = 1U; bytes[2] = (uint8_t)cause; bytes[3] = (uint8_t)oa;
|
||
bytes[4] = (uint8_t)ca; bytes[5] = (uint8_t)(ca >> 8);
|
||
bytes[6] = (uint8_t)ioa; bytes[7] = (uint8_t)(ioa >> 8); bytes[8] = (uint8_t)(ioa >> 16);
|
||
bytes[9] = (uint8_t)value;
|
||
}
|
||
|
||
/**
|
||
* 功能:发送一条手工构造的请求并消费传输通知。
|
||
* 输入参数:type——协议类型或期望事件类型;cause——完整传送原因字节;oa——发起者地址;ca——公共地址;ioa——信息对象地址;value——测试对象值或原始位模式。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:不会自动读取或应答工作事件。
|
||
*/
|
||
static void command_send(unsigned type, unsigned cause, unsigned oa, unsigned ca, unsigned ioa, unsigned value)
|
||
{
|
||
uint8_t bytes[10];
|
||
command_bytes(bytes, type, cause, oa, ca, ioa, value);
|
||
command_queue(bytes, sizeof(bytes));
|
||
command_poll();
|
||
}
|
||
|
||
/**
|
||
* 功能:扫描已经写出的APDU,返回真实业务ASDU的地址及长度,保持线上原顺序。
|
||
* 输入参数:frames——按线上顺序排列的 ASDU 视图数组;lengths——各 ASDU 的长度数组。
|
||
* 输出参数:frames——按线上顺序排列的 ASDU 视图数组;lengths——各 ASDU 的长度数组。
|
||
* 返回值:本次收集或统计到的有效业务帧数量。
|
||
* 说明:忽略S/U帧和制造拥塞的Type200填充帧;输入必须已写成完整帧。
|
||
* 输出指针借用fake.output,各用例应在缓冲内容改变前完成断言。
|
||
*/
|
||
static unsigned command_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;
|
||
CHECK(fake.sent_bytes - offset >= 6U && frame[0] == 0x68U);
|
||
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;
|
||
}
|
||
|
||
/**
|
||
* 功能:核对第index条业务输出的完整原文。
|
||
* 输入参数:index——待访问或核对的条目下标;type——协议类型或期望事件类型;cause——完整传送原因字节;oa——发起者地址;ca——公共地址;ioa——信息对象地址;value——测试对象值或原始位模式。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:同时检查长度、OA/CA/IOA、原命令值及COT。
|
||
* 期望原文由手工字节构造,避免只检查状态计数而遗漏回显或帧序错误。
|
||
*/
|
||
static void command_reply_at(unsigned index, unsigned type, unsigned cause,
|
||
unsigned oa, unsigned ca, unsigned ioa, unsigned value)
|
||
{
|
||
const uint8_t *frames[64];
|
||
size_t lengths[64];
|
||
uint8_t expected[10];
|
||
CHECK(command_collect(frames, lengths) > index);
|
||
command_bytes(expected, type, cause, oa, ca, ioa, value);
|
||
CHECK(lengths[index] == sizeof(expected));
|
||
CHECK(memcmp(frames[index], expected, sizeof(expected)) == 0);
|
||
}
|
||
|
||
/**
|
||
* 功能:返回已写出的业务I帧数量,过滤规则与command_reply_at一致。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:本次收集或统计到的有效业务帧数量。
|
||
* 说明:本辅助入口用于构造或核对上述测试场景,相关状态保存在当前测试夹具中。
|
||
*/
|
||
static unsigned command_frame_count(void)
|
||
{
|
||
const uint8_t *frames[64]; size_t lengths[64];
|
||
return command_collect(frames, lengths);
|
||
}
|
||
|
||
/* ============================================================================
|
||
* [COMMON/TRANSACTION] 专项共用辅助:动作、选择/执行、返回信息、完成、拥塞与重入
|
||
* ============================================================================ */
|
||
/**
|
||
* 功能:模拟短时应用动作:记录调用次数与模块实际交付的请求,返回用例预设结果。
|
||
* 输入参数:context——业务回调的测试上下文;request——当前业务请求(只读)。
|
||
* 输出参数:无。
|
||
* 返回值:业务动作结果,保留应用成功、业务拒绝及未知对象等协议区别。
|
||
* 说明:不发布数据、不推进网络,因此重复调用可直接识别为事务执行错误。
|
||
*/
|
||
static IEC104_CommandActionResult_t command_action(void *context, const IEC104_CommandRequest_t *request)
|
||
{
|
||
CHECK(context == &command_action_calls);
|
||
++command_action_calls;
|
||
command_action_request = *request;
|
||
return command_action_result;
|
||
}
|
||
|
||
/**
|
||
* 功能:受理并接受一次选择,推进其确认后返回原SELECT事件。
|
||
* 输入参数:type——协议类型或期望事件类型;value——测试对象值或原始位模式。
|
||
* 输出参数:无。
|
||
* 返回值:已构造或取出的事件值副本。
|
||
* 说明:固定使用CA=1、IOA=6001、OA=0x51,方便后续匹配与逐字段变异测试。
|
||
*/
|
||
static IEC104_CommandEvent_t command_select(unsigned type, unsigned value)
|
||
{
|
||
IEC104_CommandEvent_t event;
|
||
command_send(type, 6U, 0x51U, 1U, 6001U, value | 0x80U);
|
||
event = command_take(IEC104_COMMAND_SELECT);
|
||
CHECK(IEC104_Command_Accept(command, &event, command_action, &command_action_calls) == IEC104_COMMAND_REPLY_OK);
|
||
command_flush();
|
||
return event;
|
||
}
|
||
|
||
/**
|
||
* 功能:接受一次执行并返回其事件。
|
||
* 输入参数:type——协议类型或期望事件类型;value——测试对象值或原始位模式。
|
||
* 输出参数:无。
|
||
* 返回值:已构造或取出的事件值副本。
|
||
* 说明:刻意不等待确认交接,支持结果先于确认的测试。
|
||
*/
|
||
static IEC104_CommandEvent_t command_execute(unsigned type, unsigned value)
|
||
{
|
||
IEC104_CommandEvent_t event;
|
||
command_send(type, 6U, 0x51U, 1U, 6001U, value);
|
||
event = command_take(IEC104_COMMAND_EXECUTE);
|
||
CHECK(IEC104_Command_Accept(command, &event, command_action, &command_action_calls) == IEC104_COMMAND_REPLY_OK);
|
||
return event;
|
||
}
|
||
|
||
/**
|
||
* 功能:构造CA=1、监视IOA=1001、COT=11的返回信息视图。
|
||
* 输入参数:object——信息对象或 ASDU 存储;bytes——报文字节缓冲区;type——协议类型或期望事件类型;value——测试对象值或原始位模式。
|
||
* 输出参数:object——构造、解析或追加完成的对象/ASDU;bytes——写入或读出的数据字节。
|
||
* 返回值:无。
|
||
* 说明:监视IOA与遥控IOA不同。
|
||
* object借用bytes,调用方在提交返回WAIT期间必须保留并维护该缓冲。
|
||
*/
|
||
static void command_return(IEC60870_Asdu_t *object, uint8_t bytes[10], unsigned type, unsigned value)
|
||
{
|
||
command_bytes(bytes, type, 11U, 0x51U, 1U, 1001U, value);
|
||
CHECK(IEC60870_Asdu_Create_From_Buffer(object,
|
||
IEC104_Slave_Get_Application_Layer_Parameters(command_slave), bytes, 10U) == IEC60870_ASDU_OK);
|
||
}
|
||
|
||
/**
|
||
* 功能:报告给定设备结果、关闭返回信息阶段并读出FINISHED,核对成功/失败终结原因。
|
||
* 输入参数:event——业务或传输事件(只读);result——用例预设或期望的处理结果。
|
||
* 输出参数:无。
|
||
* 返回值:已构造或取出的事件值副本。
|
||
* 说明:只适用于需要的返回信息已经提交完毕、且无需额外ACK才能推进的用例。
|
||
*/
|
||
static IEC104_CommandEvent_t command_done(const IEC104_CommandEvent_t *event, IEC104_CommandResult_t result)
|
||
{
|
||
IEC104_CommandEvent_t finished;
|
||
command_flush();
|
||
CHECK(IEC104_Command_Report_Result(command, event, result) == IEC104_COMMAND_REPLY_OK);
|
||
CHECK(IEC104_Command_Complete(command, event) == IEC104_COMMAND_REPLY_OK);
|
||
command_flush();
|
||
finished = command_take(IEC104_COMMAND_FINISHED);
|
||
CHECK(finished.reason == (result == IEC104_COMMAND_RESULT_SUCCEEDED ?
|
||
IEC104_COMMAND_FINISH_COMPLETED : IEC104_COMMAND_FINISH_EXECUTION_FAILED));
|
||
command_empty();
|
||
return finished;
|
||
}
|
||
|
||
/**
|
||
* 功能:阻塞实际Net写入,再填满当前帧与HIGH容量,直到公开发送接口真实返回WAIT。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:业务层没有伪造的提交结果;解除send_blocked后由原发送管理器恢复推进。
|
||
*/
|
||
static void command_congest(void)
|
||
{
|
||
uint8_t bytes[249] = {200, 0, 3, 0, 1, 0};
|
||
IEC60870_Asdu_t filler;
|
||
unsigned index;
|
||
fake.send_blocked = 1U;
|
||
CHECK(IEC60870_Asdu_Create_From_Buffer(&filler,
|
||
IEC104_Slave_Get_Application_Layer_Parameters(command_slave), bytes, sizeof(bytes)) == IEC60870_ASDU_OK);
|
||
for (index = 0U; index < 32U; ++index) {
|
||
if (!IEC60870_MasterConnection_Send_ASDU(&command_last_input.connection, &filler)) {
|
||
CHECK(IEC104_Slave_Get_Last_Submit_Result(&command_last_input.connection) == IEC104_TCP_SUBMIT_WAIT);
|
||
return;
|
||
}
|
||
}
|
||
CHECK(0);
|
||
}
|
||
|
||
/* 供动作回调使用的已交付事件,专门验证重入时不能再次消费或销毁当前事务。 */
|
||
static IEC104_CommandEvent_t command_reentry_event;
|
||
/**
|
||
* 功能:回调中只读查询应成功,推进、消费、拒绝、销毁及重复动作应被拒绝。
|
||
* 输入参数:context——业务回调的测试上下文;request——当前业务请求(只读)。
|
||
* 输出参数:无。
|
||
* 返回值:业务动作结果,保留应用成功、业务拒绝及未知对象等协议区别。
|
||
* 说明:Cancel为无效果操作;返回后原动作仍只执行一次,并可正常报告结果。
|
||
*/
|
||
static IEC104_CommandActionResult_t command_reentry_action(void *context, const IEC104_CommandRequest_t *request)
|
||
{
|
||
IEC104_CommandTransactionInfo_t info;
|
||
IEC104_CommandEvent_t ignored;
|
||
IEC104_CommandStatus_t status;
|
||
CHECK(IEC104_Command_Get_Status(command, &status));
|
||
CHECK(IEC104_Command_Get_Transaction(command, &command_reentry_event, &info));
|
||
CHECK(!IEC104_Command_Destroy(command));
|
||
CHECK(!IEC104_Command_Process(command));
|
||
CHECK(IEC104_Command_NextEvent(command, &ignored) == IEC104_COMMAND_NEXT_ERROR);
|
||
CHECK(IEC104_Command_Accept(command, &command_reentry_event, command_action, context) == IEC104_COMMAND_REPLY_ERROR);
|
||
CHECK(IEC104_Command_Reject(command, &command_reentry_event, IEC104_COMMAND_REJECT_NEGATIVE) == IEC104_COMMAND_REPLY_ERROR);
|
||
CHECK(IEC104_Command_Handle_Event(command, &command_last_input) == IEC104_COMMAND_EVENT_ERROR);
|
||
IEC104_Command_Cancel(command);
|
||
return command_action(context, request);
|
||
}
|
||
|
||
/* ============================================================================
|
||
* [COMMAND/BASE] 基础事务用例:配置、报文、完整流程、动作结果及忙匹配
|
||
* ============================================================================ */
|
||
/**
|
||
* 功能:验证以下场景与约束:配置与实例契约:默认值、类型位边界、非法配置、重复绑定及NULL参数。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:先销毁合法空实例再逐项尝试非法配置,确保拒绝不是被已有实例掩盖。
|
||
*/
|
||
static void test_command_configuration(void)
|
||
{
|
||
IEC104_CommandConfig_t config, invalid;
|
||
IEC104_CommandStatus_t status;
|
||
unsigned index;
|
||
IEC104_Command_Config_Default(&config);
|
||
CHECK(config.type_mask == UINT16_C(0x3fff));
|
||
CHECK(config.points == NULL && config.point_count == 0U);
|
||
CHECK(config.select_timeout_ms == 30000U && config.decision_timeout_ms == 15000U);
|
||
CHECK(config.execute_timeout_ms == 60000U);
|
||
CHECK(config.complete_timeout_ms == 30000U && config.handover_timeout_ms == 60000U);
|
||
CHECK(IEC104_COMMAND_TYPE_BIT(44U) == 0U && IEC104_COMMAND_TYPE_BIT(52U) == 0U);
|
||
CHECK(IEC104_COMMAND_TYPE_BIT(58U) == 128U && IEC104_COMMAND_TYPE_BIT(64U) == 8192U);
|
||
CHECK(IEC104_COMMAND_TYPE_BIT(65U) == 0U);
|
||
CHECK(IEC104_Command_Create(NULL, &config) == NULL);
|
||
CHECK(!IEC104_Command_Destroy(NULL));
|
||
CHECK(!IEC104_Command_Get_Status(NULL, &status));
|
||
command_open(NULL);
|
||
CHECK(IEC104_Command_Create(command_slave, &config) == NULL);
|
||
CHECK(IEC104_Command_Destroy(command));
|
||
for (index = 0U; index < 5U; ++index) {
|
||
invalid = config;
|
||
switch (index) {
|
||
case 0U: invalid.type_mask = 0U; break;
|
||
case 1U: invalid.type_mask |= UINT16_C(0x4000); break;
|
||
case 2U: invalid.select_timeout_ms = 0U; break;
|
||
case 3U: invalid.point_count = 1U; break;
|
||
default: invalid.points = command_select_points; break;
|
||
}
|
||
CHECK(IEC104_Command_Create(command_slave, &invalid) == NULL);
|
||
}
|
||
CHECK(IEC104_Command_Create(command_slave, NULL) == NULL);
|
||
command = IEC104_Command_Create(command_slave, &config);
|
||
CHECK(command != NULL);
|
||
command_close();
|
||
++command_checks;
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:接收校验顺序:先COT、再CA、再IOA、最后对象内容。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:TEST/P/N随否定回显保留。
|
||
* 无唯一完整对象时静默丢弃,SQ和尾字节异常则规范成单对象10字节否定。
|
||
* 另验证未支持或被type_mask禁用的类型返回IGNORED,不误交付工作事件。
|
||
*/
|
||
static void test_command_wire_validation(void)
|
||
{
|
||
static const struct { unsigned type, cot, ca, ioa, value, cause; } cases[] = {
|
||
{45, 5, 65535, 0, 2, 45}, {45, 8, 65535, 0, 2, 46},
|
||
{45, 6, 2, 0, 2, 46}, {45, 6, 1, 0, 2, 47},
|
||
{45, 6, 1, 6001, 2, 7}, {46, 6, 1, 6001, 0, 7},
|
||
{46, 6, 1, 6001, 3, 7}, {46, 8, 1, 6001, 3, 9},
|
||
{45, 0x46, 1, 6001, 1, 7}, {45, 0x86, 1, 6001, 1, 0x87}
|
||
};
|
||
unsigned index;
|
||
for (index = 0U; index < sizeof(cases) / sizeof(cases[0]); ++index) {
|
||
command_open(NULL);
|
||
command_send(cases[index].type, cases[index].cot, 0x61U, cases[index].ca,
|
||
cases[index].ioa, cases[index].value);
|
||
command_flush();
|
||
CHECK(command_frame_count() == 1U);
|
||
command_reply_at(0U, cases[index].type, cases[index].cause | 0x40U,
|
||
0x61U, cases[index].ca, cases[index].ioa, cases[index].value);
|
||
CHECK(command_status.rejected == 1U && command_action_calls == 0U);
|
||
command_empty();
|
||
command_close();
|
||
}
|
||
for (index = 0U; index < 5U; ++index) {
|
||
uint8_t bytes[14];
|
||
size_t length = 10U;
|
||
command_open(NULL);
|
||
command_bytes(bytes, 45U, 6U, 0x62U, 1U, 6001U, 0x81U);
|
||
switch (index) {
|
||
case 0U: bytes[1] = 0U; break;
|
||
case 1U: bytes[1] = 2U; length = 14U; memset(bytes + 10U, 0, 4U); break;
|
||
case 2U: length = 9U; break;
|
||
case 3U: bytes[1] = 0x81U; break;
|
||
default: bytes[10] = 0x55U; length = 11U; break;
|
||
}
|
||
command_queue(bytes, length); command_poll(); command_flush();
|
||
CHECK(command_frame_count() == (index < 3U ? 0U : 1U));
|
||
if (index >= 3U) { command_reply_at(0U, 45U, 0x47U, 0x62U, 1U, 6001U, 0x81U); }
|
||
command_empty(); command_close();
|
||
}
|
||
{
|
||
IEC104_CommandConfig_t config;
|
||
uint8_t timed[17] = {0};
|
||
command_config_default(&config);
|
||
config.type_mask =
|
||
IEC104_COMMAND_TYPE_BIT(45U) | IEC104_COMMAND_TYPE_BIT(46U);
|
||
command_open(&config);
|
||
command_send(47U, 6U, 0U, 1U, 6001U, 1U);
|
||
CHECK(command_last_handled == IEC104_COMMAND_EVENT_IGNORED);
|
||
command_bytes(timed, 58U, 6U, 0U, 1U, 6001U, 1U);
|
||
timed[14] = 1U; timed[15] = 1U; timed[16] = 26U;
|
||
command_queue(timed, sizeof(timed)); command_poll();
|
||
}
|
||
CHECK(command_last_handled == IEC104_COMMAND_EVENT_IGNORED);
|
||
command_empty(); command_close();
|
||
{
|
||
IEC104_CommandConfig_t config;
|
||
command_config_default(&config);
|
||
config.type_mask = IEC104_COMMAND_TYPE_BIT(46U);
|
||
command_open(&config);
|
||
command_send(45U, 6U, 0U, 1U, 6001U, 0x81U);
|
||
CHECK(command_last_handled == IEC104_COMMAND_EVENT_IGNORED);
|
||
command_empty();
|
||
command_send(46U, 6U, 0U, 1U, 6001U, 0x82U);
|
||
CHECK(command_take(IEC104_COMMAND_SELECT).request.type_id == 46U);
|
||
command_close();
|
||
}
|
||
++command_checks;
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:单/双命令的完整选择执行链:分别提交0、1、2帧返回信息,逐字节检查帧序。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:同时核对选择与执行属于同一事务但使用不同事件令牌、结果冻结、Complete一次性、
|
||
* 旧SELECT只能查询事务不能报告执行结果,以及槽回收后旧令牌失效。
|
||
*/
|
||
static void test_command_complete_flows(void)
|
||
{
|
||
unsigned type, count;
|
||
for (type = 45U; type <= 46U; ++type) {
|
||
for (count = 0U; count <= 2U; ++count) {
|
||
IEC104_CommandEvent_t selection, execution, finished;
|
||
IEC104_CommandTransactionInfo_t info;
|
||
IEC60870_Asdu_t data;
|
||
uint8_t bytes[10];
|
||
unsigned index, value = type == 45U ? 1U : 2U;
|
||
command_open(NULL);
|
||
selection = command_select(type, value | 4U);
|
||
CHECK(selection.request.state == value && selection.request.qualifier == 1U);
|
||
CHECK(selection.request.is_select && !selection.request.selected);
|
||
execution = command_execute(type, value | 4U);
|
||
CHECK(execution.request.selected && !execution.request.is_select);
|
||
CHECK(execution.transaction_id == selection.transaction_id);
|
||
CHECK(execution.event_serial != selection.event_serial);
|
||
command_flush();
|
||
CHECK(IEC104_Command_Get_Transaction(command, &selection, &info) && info.active);
|
||
CHECK(info.phase == IEC104_COMMAND_PHASE_EXECUTING && info.confirm_submitted);
|
||
CHECK(IEC104_Command_Report_Result(command, &selection, IEC104_COMMAND_RESULT_SUCCEEDED) == IEC104_COMMAND_REPLY_STALE);
|
||
CHECK(IEC104_Command_Complete(command, &execution) == IEC104_COMMAND_REPLY_ERROR);
|
||
CHECK(IEC104_Command_Report_Result(command, &execution, IEC104_COMMAND_RESULT_SUCCEEDED) == IEC104_COMMAND_REPLY_OK);
|
||
CHECK(IEC104_Command_Report_Result(command, &execution, IEC104_COMMAND_RESULT_FAILED) == IEC104_COMMAND_REPLY_ERROR);
|
||
for (index = 0U; index < count; ++index) {
|
||
command_return(&data, bytes, type == 45U ? 1U : 3U, value);
|
||
CHECK(IEC104_Command_Submit_Return_Info(command, &execution, &data) == IEC104_COMMAND_REPLY_OK);
|
||
command_poll();
|
||
}
|
||
CHECK(IEC104_Command_Complete(command, &execution) == IEC104_COMMAND_REPLY_OK);
|
||
CHECK(IEC104_Command_Complete(command, &execution) == IEC104_COMMAND_REPLY_ERROR);
|
||
command_return(&data, bytes, 1U, 1U);
|
||
CHECK(IEC104_Command_Submit_Return_Info(command, &execution, &data) == IEC104_COMMAND_REPLY_ERROR);
|
||
command_flush();
|
||
CHECK(command_frame_count() == count + 3U);
|
||
command_reply_at(0U, type, 7U, 0x51U, 1U, 6001U, value | 0x84U);
|
||
command_reply_at(1U, type, 7U, 0x51U, 1U, 6001U, value | 4U);
|
||
for (index = 0U; index < count; ++index) {
|
||
command_reply_at(index + 2U, type == 45U ? 1U : 3U, 11U, 0x51U, 1U, 1001U, value);
|
||
}
|
||
command_reply_at(count + 2U, type, 10U, 0x51U, 1U, 6001U, value | 4U);
|
||
finished = command_take(IEC104_COMMAND_FINISHED);
|
||
CHECK(finished.reason == IEC104_COMMAND_FINISH_COMPLETED && finished.select_effect && finished.execute_effect);
|
||
CHECK(finished.request.receive_serial == execution.request.receive_serial);
|
||
CHECK(command_action_calls == 2U);
|
||
CHECK(!IEC104_Command_Get_Transaction(command, &execution, &info));
|
||
CHECK(IEC104_Command_Complete(command, &execution) == IEC104_COMMAND_REPLY_STALE);
|
||
command_empty(); command_close();
|
||
}
|
||
}
|
||
++command_checks;
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:直接执行采用固定收尾:成功Complete回肯定TERM,明确失败Complete回否定TERM。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:线上的P/N与FINISHED中的已知执行结果一致,不再提供关闭终止帧的配置。
|
||
*/
|
||
static void test_command_result_policies(void)
|
||
{
|
||
unsigned success;
|
||
for (success = 0U; success < 2U; ++success) {
|
||
IEC104_CommandConfig_t config;
|
||
IEC104_CommandEvent_t event, finished;
|
||
command_config_default(&config);
|
||
command_config_mode(&config, IEC104_COMMAND_MODE_DIRECT);
|
||
command_open(&config);
|
||
event = command_execute(45U, 1U);
|
||
CHECK(!event.request.selected);
|
||
finished = command_done(&event, success ? IEC104_COMMAND_RESULT_SUCCEEDED : IEC104_COMMAND_RESULT_FAILED);
|
||
CHECK(finished.execute_effect && !finished.select_effect);
|
||
CHECK(command_frame_count() == 2U && command_action_calls == 1U);
|
||
command_reply_at(0U, 45U, 7U, 0x51U, 1U, 6001U, 1U);
|
||
command_reply_at(1U, 45U, success ? 10U : 0x4aU, 0x51U, 1U, 6001U, 1U);
|
||
CHECK(IEC104_Command_Get_Status(command, &command_status));
|
||
CHECK(command_status.negative_submitted == (success ? 0U : 1U));
|
||
command_close();
|
||
}
|
||
++command_checks;
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:选择与执行各覆盖NOT_STARTED、STARTED、FAILED,检查确认、原因及副作用标志。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:Accept的OK只代表事件消费;再次Accept不能重复动作。无返校动作的NULL选择
|
||
* 可以生效,但不得错误标记为曾产生物理选择副作用。
|
||
*/
|
||
static void test_command_action_outcomes(void)
|
||
{
|
||
unsigned selected, outcome;
|
||
for (selected = 0U; selected < 2U; ++selected) {
|
||
for (outcome = 0U; outcome < 3U; ++outcome) {
|
||
IEC104_CommandConfig_t config;
|
||
IEC104_CommandEvent_t event, finished;
|
||
command_config_default(&config);
|
||
if (!selected) { command_config_mode(&config, IEC104_COMMAND_MODE_DIRECT); }
|
||
command_open(&config);
|
||
command_send(45U, 6U, 0x51U, 1U, 6001U, selected ? 0x81U : 1U);
|
||
event = command_take(selected ? IEC104_COMMAND_SELECT : IEC104_COMMAND_EXECUTE);
|
||
command_action_result = (IEC104_CommandActionResult_t)outcome;
|
||
CHECK(IEC104_Command_Accept(command, &event, command_action, &command_action_calls) == IEC104_COMMAND_REPLY_OK);
|
||
CHECK(IEC104_Command_Accept(command, &event, command_action, &command_action_calls) == IEC104_COMMAND_REPLY_STALE);
|
||
CHECK(command_action_calls == 1U);
|
||
command_flush();
|
||
command_reply_at(0U, 45U, outcome == IEC104_COMMAND_ACTION_STARTED ? 7U : 0x47U,
|
||
0x51U, 1U, 6001U, selected ? 0x81U : 1U);
|
||
if (outcome == IEC104_COMMAND_ACTION_STARTED) {
|
||
IEC104_Command_Cancel(command);
|
||
finished = command_take(IEC104_COMMAND_FINISHED);
|
||
CHECK(finished.reason == IEC104_COMMAND_FINISH_CANCELLED);
|
||
} else {
|
||
finished = command_take(IEC104_COMMAND_FINISHED);
|
||
CHECK(finished.reason == (outcome == IEC104_COMMAND_ACTION_FAILED ?
|
||
IEC104_COMMAND_FINISH_ACTION_FAILED : IEC104_COMMAND_FINISH_REJECTED));
|
||
}
|
||
CHECK(finished.select_effect == (selected && outcome != IEC104_COMMAND_ACTION_NOT_STARTED));
|
||
CHECK(finished.execute_effect == (!selected && outcome != IEC104_COMMAND_ACTION_NOT_STARTED));
|
||
command_close();
|
||
}
|
||
}
|
||
{
|
||
IEC104_CommandEvent_t event, finished;
|
||
command_open(NULL); command_send(45U, 6U, 0x51U, 1U, 6001U, 0x81U);
|
||
event = command_take(IEC104_COMMAND_SELECT);
|
||
CHECK(IEC104_Command_Accept(command, &event, NULL, NULL) == IEC104_COMMAND_REPLY_OK);
|
||
command_flush(); IEC104_Command_Cancel(command);
|
||
finished = command_take(IEC104_COMMAND_FINISHED);
|
||
CHECK(!finished.select_effect && command_action_calls == 0U);
|
||
command_close();
|
||
}
|
||
++command_checks;
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:事件身份和拒绝接口:分别篡改实例、事务、事件序号和类型,旧事件不得执行动作。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:Reject只能消费一次;ENDED仍可查询,槽回收后查询失败且输出不变,新事务也不能
|
||
* 重新接纳上一事务的令牌。
|
||
*/
|
||
static void test_command_rejection_and_stale(void)
|
||
{
|
||
IEC104_CommandEvent_t event, stale, finished;
|
||
IEC104_CommandTransactionInfo_t info, before;
|
||
unsigned index;
|
||
command_open(NULL); command_send(45U, 6U, 0x51U, 1U, 6001U, 0x81U);
|
||
event = command_take(IEC104_COMMAND_SELECT);
|
||
for (index = 0U; index < 4U; ++index) {
|
||
stale = event;
|
||
switch (index) {
|
||
case 0U: ++stale.instance_id; break;
|
||
case 1U: ++stale.transaction_id; break;
|
||
case 2U: ++stale.event_serial; break;
|
||
default: stale.type = IEC104_COMMAND_EXECUTE; break;
|
||
}
|
||
CHECK(IEC104_Command_Accept(command, &stale, command_action, &command_action_calls) == IEC104_COMMAND_REPLY_STALE);
|
||
}
|
||
CHECK(IEC104_Command_Report_Result(command, &event, IEC104_COMMAND_RESULT_SUCCEEDED) == IEC104_COMMAND_REPLY_STALE);
|
||
CHECK(IEC104_Command_Reject(command, &event, (IEC104_CommandRejectCause_t)0) == IEC104_COMMAND_REPLY_ERROR);
|
||
CHECK(IEC104_Command_Reject(command, &event, IEC104_COMMAND_REJECT_UNKNOWN_IOA) == IEC104_COMMAND_REPLY_OK);
|
||
CHECK(IEC104_Command_Reject(command, &event, IEC104_COMMAND_REJECT_NEGATIVE) == IEC104_COMMAND_REPLY_STALE);
|
||
command_flush(); command_reply_at(0U, 45U, 0x6fU, 0x51U, 1U, 6001U, 0x81U);
|
||
CHECK(IEC104_Command_Get_Transaction(command, &event, &info) && !info.active);
|
||
finished = command_take(IEC104_COMMAND_FINISHED);
|
||
CHECK(finished.reason == IEC104_COMMAND_FINISH_REJECTED && command_action_calls == 0U);
|
||
memset(&info, 0x5a, sizeof(info)); before = info;
|
||
CHECK(!IEC104_Command_Get_Transaction(command, &event, &info));
|
||
CHECK(memcmp(&before, &info, sizeof(info)) == 0);
|
||
command_send(45U, 6U, 0x51U, 1U, 6001U, 0x81U);
|
||
CHECK(IEC104_Command_Accept(command, &event, command_action, &command_action_calls) == IEC104_COMMAND_REPLY_STALE);
|
||
command_close();
|
||
++command_checks;
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:选择已确认后逐项改变执行类型、状态、QU、OA,必须取消原选择并回显新请求。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:其他点的新选择只得到忙否定,原选择仍可正常执行;默认禁止无选择直接执行。
|
||
*/
|
||
static void test_command_matching_and_busy(void)
|
||
{
|
||
unsigned change;
|
||
for (change = 0U; change < 4U; ++change) {
|
||
IEC104_CommandEvent_t selected, finished;
|
||
unsigned type = change == 0U ? 46U : 45U;
|
||
unsigned value = change == 0U ? 2U : (change == 1U ? 0U : (change == 2U ? 5U : 1U));
|
||
command_open(NULL); selected = command_select(45U, 1U);
|
||
command_send(type, 6U, change == 3U ? 0x52U : 0x51U, 1U, 6001U, value);
|
||
command_flush();
|
||
finished = command_take(IEC104_COMMAND_FINISHED);
|
||
CHECK(finished.reason == IEC104_COMMAND_FINISH_MISMATCH);
|
||
CHECK(finished.request.receive_serial == selected.request.receive_serial && finished.request.type_id == 45U);
|
||
command_reply_at(1U, type, 0x47U, change == 3U ? 0x52U : 0x51U, 1U, 6001U, value);
|
||
CHECK(command_action_calls == 1U); command_close();
|
||
}
|
||
{
|
||
IEC104_CommandEvent_t event;
|
||
command_open(NULL); (void)command_select(45U, 1U);
|
||
command_send(45U, 6U, 0x51U, 1U, 6002U, 0x81U); command_flush();
|
||
CHECK(command_status.busy && command_status.busy_rejected == 1U);
|
||
command_reply_at(1U, 45U, 0x47U, 0x51U, 1U, 6002U, 0x81U);
|
||
event = command_execute(45U, 1U); (void)command_done(&event, IEC104_COMMAND_RESULT_SUCCEEDED);
|
||
command_close();
|
||
}
|
||
command_open(NULL); command_send(45U, 6U, 0x51U, 1U, 6001U, 1U); command_flush();
|
||
CHECK(!command_status.busy); command_reply_at(0U, 45U, 0x47U, 0x51U, 1U, 6001U, 1U);
|
||
command_empty(); command_close();
|
||
++command_checks;
|
||
}
|
||
|
||
/* ============================================================================
|
||
* [COMMAND/DUPLICATE] 决定期间重复请求:非选择重发、期限、校验和身份边界
|
||
* ============================================================================ */
|
||
/**
|
||
* 功能:验证以下场景与约束:决定窗口内不触发重复选择复归的同OA激活仍静默:覆盖选择待决定、直接执行、选择后执行,
|
||
* 以及工作事件未取和已取两种情况。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:未取分支把原请求与重发放在同一批输入;
|
||
* 已取分支制造真实发送背压。SELECT_WAIT只注入执行;EXECUTE_WAIT同时注入选择和执行。
|
||
* 原工作身份、动作参数及决定期限保持不变,最终只出现原请求自己的确认。
|
||
*/
|
||
static void test_command_pending_same_point(void)
|
||
{
|
||
unsigned type, phase, taken;
|
||
for (type = 45U; type <= 46U; ++type) {
|
||
for (phase = 0U; phase < 3U; ++phase) {
|
||
for (taken = 0U; taken < 2U; ++taken) {
|
||
IEC104_CommandConfig_t config;
|
||
IEC104_CommandEvent_t event;
|
||
IEC104_CommandTransactionInfo_t info;
|
||
uint8_t bytes[10];
|
||
unsigned state = type == 45U ? 1U : 2U;
|
||
unsigned select_bit = phase == 0U ? 0x80U : 0U;
|
||
unsigned prior = phase == 2U ? 1U : 0U;
|
||
uint64_t started, original_receive;
|
||
command_config_default(&config);
|
||
config.decision_timeout_ms = 100U;
|
||
if (phase == 1U) { command_config_mode(&config, IEC104_COMMAND_MODE_DIRECT); }
|
||
command_open(&config);
|
||
if (phase == 2U) { (void)command_select(type, state); }
|
||
started = fake.now;
|
||
command_bytes(bytes, type, 6U, 0x51U, 1U, 6001U, state | select_bit);
|
||
command_queue(bytes, sizeof(bytes));
|
||
if (taken != 0U) {
|
||
command_poll();
|
||
event = command_take(phase == 0U ? IEC104_COMMAND_SELECT : IEC104_COMMAND_EXECUTE);
|
||
command_congest();
|
||
}
|
||
bytes[9] &= 0x7fU;
|
||
command_queue(bytes, sizeof(bytes)); command_flush();
|
||
original_receive = command_last_input.transport.data.i_frame.receive_serial - 1U;
|
||
fake.now += 5U;
|
||
command_send(type, 6U, 0x51U, 1U, 6001U, state | (select_bit ^ 0x80U));
|
||
command_send(type, 6U, 0x51U, 1U, 6001U, type == 45U ? 0U : 1U);
|
||
command_send(type, 6U, 0x51U, 1U, 6001U, state | 4U);
|
||
command_send(type == 45U ? 46U : 45U, 6U, 0x51U, 1U, 6001U,
|
||
type == 45U ? 2U : 1U);
|
||
CHECK(command_last_handled == IEC104_COMMAND_EVENT_HANDLED);
|
||
command_flush();
|
||
CHECK(command_status.accepted == prior + 1U && command_status.dropped_requests == 5U);
|
||
CHECK(command_status.rejected == 0U && command_status.busy_rejected == 0U &&
|
||
command_status.overloads == 0U && command_status.negative_submitted == 0U);
|
||
CHECK(command_status.pending_replies == 0U && command_status.pending_events == (taken == 0U ? 1U : 0U));
|
||
CHECK(command_status.timer_active && command_status.timeout_remaining_ms == 95U);
|
||
CHECK(command_frame_count() == prior && command_action_calls == prior);
|
||
if (taken == 0U) { event = command_take(phase == 0U ? IEC104_COMMAND_SELECT : IEC104_COMMAND_EXECUTE); }
|
||
CHECK(event.request.type_id == type && event.request.originator_address == 0x51U &&
|
||
event.request.state == state && event.request.qualifier == 0U &&
|
||
event.request.is_select == (phase == 0U) && event.request.selected == (phase == 2U));
|
||
CHECK(event.request.accepted_ms == started && event.request.receive_serial == original_receive);
|
||
CHECK(IEC104_Command_Get_Transaction(command, &event, &info) && info.active &&
|
||
info.phase == (phase == 0U ? IEC104_COMMAND_PHASE_SELECT_WAIT : IEC104_COMMAND_PHASE_EXECUTE_WAIT));
|
||
command_empty();
|
||
fake.send_blocked = 0U; command_flush();
|
||
CHECK(command_frame_count() == prior);
|
||
CHECK(IEC104_Command_Accept(command, &event, command_action, &command_action_calls) == IEC104_COMMAND_REPLY_OK);
|
||
command_flush();
|
||
CHECK(command_action_calls == prior + 1U && command_frame_count() == prior + 1U);
|
||
CHECK(command_action_request.receive_serial == original_receive &&
|
||
command_action_request.state == state && command_action_request.qualifier == 0U);
|
||
command_reply_at(prior, type, 7U, 0x51U, 1U, 6001U, state | select_bit);
|
||
if (phase != 0U) { (void)command_done(&event, IEC104_COMMAND_RESULT_SUCCEEDED); }
|
||
command_close();
|
||
}
|
||
}
|
||
}
|
||
++command_checks;
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:不触发重复选择的异OA同点激活必须否定回显,不能吞成原请求的重发。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:覆盖SELECT_WAIT、直接执行及选择后执行的EXECUTE_WAIT,以及真实HIGH背压下的WAIT重试。
|
||
* 原工作事件留到拒绝之后才取,验证新请求不能替换事件、动作参数或决定期限;同OA仍静默。
|
||
*/
|
||
static void test_command_pending_other_originator(void)
|
||
{
|
||
unsigned phase, blocked;
|
||
for (phase = 0U; phase < 3U; ++phase) {
|
||
for (blocked = 0U; blocked < 2U; ++blocked) {
|
||
IEC104_CommandConfig_t config;
|
||
IEC104_CommandEvent_t event;
|
||
IEC104_CommandTransactionInfo_t info;
|
||
const unsigned prior = phase == 2U ? 1U : 0U;
|
||
const unsigned value = phase == 0U ? 0x81U : 1U;
|
||
const unsigned other_value = phase == 0U ? 6U : 0x86U;
|
||
uint64_t started, original_receive;
|
||
command_config_default(&config);
|
||
config.decision_timeout_ms = 100U;
|
||
if (phase == 1U) { command_config_mode(&config, IEC104_COMMAND_MODE_DIRECT); }
|
||
command_open(&config);
|
||
if (phase == 2U) { (void)command_select(45U, 1U); }
|
||
started = fake.now;
|
||
command_send(45U, 6U, 0x51U, 1U, 6001U, value);
|
||
original_receive = command_last_input.transport.data.i_frame.receive_serial;
|
||
if (blocked != 0U) { command_congest(); }
|
||
fake.now += 5U;
|
||
/* 同时改变Type、OA和命令字段;否定必须逐字节对应这个新请求。 */
|
||
command_send(46U, 6U, 0x52U, 1U, 6001U, other_value);
|
||
command_send(45U, 6U, 0x51U, 1U, 6001U, value & 0x7fU);
|
||
command_flush();
|
||
CHECK(command_status.accepted == prior + 1U && command_status.rejected == 1U &&
|
||
command_status.busy_rejected == 1U && command_status.dropped_requests == 1U);
|
||
CHECK(command_status.overloads == 0U && command_status.pending_events == 1U &&
|
||
command_status.timer_active && command_status.timeout_remaining_ms == 95U);
|
||
CHECK(command_status.pending_replies == blocked &&
|
||
command_status.negative_submitted == (blocked == 0U ? 1U : 0U));
|
||
CHECK(command_frame_count() == prior + (blocked == 0U ? 1U : 0U) && command_action_calls == prior);
|
||
if (blocked != 0U) { CHECK(command_status.waits != 0U); }
|
||
event = command_take(phase == 0U ? IEC104_COMMAND_SELECT : IEC104_COMMAND_EXECUTE);
|
||
CHECK(event.request.type_id == 45U && event.request.originator_address == 0x51U &&
|
||
event.request.state == 1U && event.request.qualifier == 0U &&
|
||
event.request.is_select == (phase == 0U) && event.request.selected == (phase == 2U));
|
||
CHECK(event.request.accepted_ms == started && event.request.receive_serial == original_receive);
|
||
CHECK(IEC104_Command_Get_Transaction(command, &event, &info) && info.active &&
|
||
info.phase == (phase == 0U ? IEC104_COMMAND_PHASE_SELECT_WAIT : IEC104_COMMAND_PHASE_EXECUTE_WAIT));
|
||
command_empty();
|
||
fake.send_blocked = 0U;
|
||
command_flush();
|
||
CHECK(command_frame_count() == prior + 1U && command_status.pending_replies == 0U &&
|
||
command_status.negative_submitted == 1U && command_status.timeout_remaining_ms == 95U);
|
||
command_reply_at(prior, 46U, 0x47U, 0x52U, 1U, 6001U, other_value);
|
||
CHECK(IEC104_Command_Accept(command, &event, command_action, &command_action_calls) == IEC104_COMMAND_REPLY_OK);
|
||
CHECK(IEC104_Command_Accept(command, &event, command_action, &command_action_calls) == IEC104_COMMAND_REPLY_STALE);
|
||
command_flush();
|
||
CHECK(command_action_calls == prior + 1U && command_frame_count() == prior + 2U &&
|
||
command_action_request.originator_address == 0x51U && command_action_request.receive_serial == original_receive);
|
||
command_reply_at(prior + 1U, 45U, 7U, 0x51U, 1U, 6001U, value);
|
||
if (phase != 0U) { (void)command_done(&event, IEC104_COMMAND_RESULT_SUCCEEDED); }
|
||
command_close();
|
||
}
|
||
}
|
||
++command_checks;
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:不同OA的同点执行忙否定复用独立短回复池:真实WAIT时填满,再来的只计丢新。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:满池既不能覆盖已排队否定,也不能覆盖原工作事件;解除背压后按各请求OA FIFO回显,
|
||
* 原SELECT/EXECUTE依旧能Accept一次,决定期限不因拒绝或过载续期。
|
||
*/
|
||
static void test_command_pending_other_originator_overload(void)
|
||
{
|
||
unsigned execute, index;
|
||
for (execute = 0U; execute < 2U; ++execute) {
|
||
IEC104_CommandConfig_t config;
|
||
IEC104_CommandEvent_t event;
|
||
const unsigned value = execute != 0U ? 1U : 0x81U;
|
||
uint64_t original_receive;
|
||
command_config_default(&config);
|
||
config.decision_timeout_ms = 100U;
|
||
if (execute != 0U) { command_config_mode(&config, IEC104_COMMAND_MODE_DIRECT); }
|
||
command_open(&config);
|
||
command_send(45U, 6U, 0x51U, 1U, 6001U, value);
|
||
original_receive = command_last_input.transport.data.i_frame.receive_serial;
|
||
command_congest();
|
||
fake.now += 5U;
|
||
for (index = 0U; index < IEC104_COMMAND_REPLY_CAPACITY + 2U; ++index) {
|
||
command_send(46U, 6U, 0x60U + index, 1U, 6001U, 2U | ((index & 3U) << 2));
|
||
}
|
||
command_flush();
|
||
CHECK(command_status.pending_replies == IEC104_COMMAND_REPLY_CAPACITY && command_status.waits != 0U);
|
||
CHECK(command_status.rejected == IEC104_COMMAND_REPLY_CAPACITY + 2U &&
|
||
command_status.busy_rejected == IEC104_COMMAND_REPLY_CAPACITY + 2U &&
|
||
command_status.overloads == 2U && command_status.dropped_requests == 2U);
|
||
CHECK(command_status.accepted == 1U && command_status.pending_events == 1U &&
|
||
command_status.timeout_remaining_ms == 95U && command_action_calls == 0U && command_frame_count() == 0U);
|
||
event = command_take(execute != 0U ? IEC104_COMMAND_EXECUTE : IEC104_COMMAND_SELECT);
|
||
CHECK(event.request.originator_address == 0x51U && event.request.type_id == 45U &&
|
||
event.request.receive_serial == original_receive && event.request.state == 1U && event.request.qualifier == 0U);
|
||
command_empty();
|
||
fake.send_blocked = 0U;
|
||
command_flush();
|
||
CHECK(command_status.pending_replies == 0U && command_status.timeout_remaining_ms == 95U &&
|
||
command_frame_count() == IEC104_COMMAND_REPLY_CAPACITY);
|
||
for (index = 0U; index < IEC104_COMMAND_REPLY_CAPACITY; ++index) {
|
||
command_reply_at(index, 46U, 0x47U, 0x60U + index, 1U, 6001U, 2U | ((index & 3U) << 2));
|
||
}
|
||
CHECK(IEC104_Command_Accept(command, &event, command_action, &command_action_calls) == IEC104_COMMAND_REPLY_OK);
|
||
CHECK(IEC104_Command_Accept(command, &event, command_action, &command_action_calls) == IEC104_COMMAND_REPLY_STALE);
|
||
command_flush();
|
||
CHECK(command_action_calls == 1U && command_frame_count() == IEC104_COMMAND_REPLY_CAPACITY + 1U);
|
||
command_reply_at(IEC104_COMMAND_REPLY_CAPACITY, 45U, 7U, 0x51U, 1U, 6001U, value);
|
||
if (execute != 0U) { (void)command_done(&event, IEC104_COMMAND_RESULT_SUCCEEDED); }
|
||
command_close();
|
||
}
|
||
++command_checks;
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:同OA的执行重发不能续期,也不能替换超时确认的回显来源。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:决定到期后只拒绝原请求;
|
||
* FINISHED仍按事务历史配对,选择曾交付时未读EXECUTE超时也须通知清理。
|
||
*/
|
||
static void test_command_pending_repeat_deadline(void)
|
||
{
|
||
unsigned phase, taken;
|
||
for (phase = 0U; phase < 3U; ++phase) {
|
||
for (taken = 0U; taken < 2U; ++taken) {
|
||
IEC104_CommandConfig_t config;
|
||
IEC104_CommandEvent_t event, finished;
|
||
unsigned prior = phase == 2U ? 1U : 0U;
|
||
unsigned value = phase == 0U ? 0x82U : 2U;
|
||
uint64_t original_receive;
|
||
command_config_default(&config); config.decision_timeout_ms = 10U;
|
||
if (phase == 1U) { command_config_mode(&config, IEC104_COMMAND_MODE_DIRECT); }
|
||
command_open(&config);
|
||
if (phase == 2U) { (void)command_select(46U, 2U); }
|
||
command_send(46U, 6U, 0x51U, 1U, 6001U, value);
|
||
original_receive = command_last_input.transport.data.i_frame.receive_serial;
|
||
if (taken != 0U) { event = command_take(phase == 0U ? IEC104_COMMAND_SELECT : IEC104_COMMAND_EXECUTE); }
|
||
fake.now += 9U; command_send(45U, 6U, 0x51U, 1U, 6001U, 5U); command_process();
|
||
CHECK(command_status.dropped_requests == 1U && command_status.timeout_remaining_ms == 1U);
|
||
CHECK(command_frame_count() == prior);
|
||
++fake.now; command_flush();
|
||
CHECK(command_status.decision_timeouts == 1U && command_action_calls == prior);
|
||
CHECK(command_frame_count() == prior + 1U);
|
||
command_reply_at(prior, 46U, 0x47U, 0x51U, 1U, 6001U, value);
|
||
if (taken != 0U || phase == 2U) {
|
||
finished = command_take(IEC104_COMMAND_FINISHED);
|
||
CHECK(finished.reason == IEC104_COMMAND_FINISH_DECISION_TIMEOUT &&
|
||
finished.request.receive_serial == original_receive && finished.request.type_id == 46U);
|
||
}
|
||
if (taken != 0U) {
|
||
CHECK(IEC104_Command_Accept(command, &event, command_action, &command_action_calls) == IEC104_COMMAND_REPLY_STALE);
|
||
}
|
||
command_empty(); command_close();
|
||
}
|
||
}
|
||
++command_checks;
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:静默策略只作用于通过校验的同OA同点同T的COT=6:禁用类型仍IGNORED,错误请求仍答错,
|
||
* TEST与其他IOA/站点均忙拒绝,合法真实撤销仍能终结原待决定事务且回显撤销请求。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。
|
||
*/
|
||
static void test_command_pending_repeat_boundaries(void)
|
||
{
|
||
static const unsigned invalid[][3] = {
|
||
{3U, 0x81U, 0x6dU}, {0x86U, 0x81U, 0xc7U},
|
||
{0x46U, 0x81U, 0x47U}, {6U, 0x83U, 0x47U}
|
||
};
|
||
IEC104_CommandConfig_t config;
|
||
IEC104_CommandEvent_t event, finished;
|
||
IEC104_Station_t other = {0};
|
||
unsigned index;
|
||
command_config_default(&config);
|
||
config.type_mask = IEC104_COMMAND_TYPE_BIT(45U);
|
||
command_open(&config);
|
||
CHECK(IEC104_Slave_Add_Station(command_slave, &other, 2U, &other) == IEC104_STATION_OK);
|
||
command_send(45U, 6U, 0x51U, 1U, 6001U, 0x81U); event = command_take(IEC104_COMMAND_SELECT);
|
||
command_send(45U, 6U, 0x51U, 1U, 6001U, 0U);
|
||
command_send(46U, 6U, 0x51U, 1U, 6001U, 0x82U);
|
||
CHECK(command_last_handled == IEC104_COMMAND_EVENT_IGNORED);
|
||
for (index = 0U; index < sizeof(invalid) / sizeof(invalid[0]); ++index) {
|
||
command_send(45U, invalid[index][0], 0x51U, 1U, 6001U, invalid[index][1]); command_flush();
|
||
command_reply_at(index, 45U, invalid[index][2], 0x51U, 1U, 6001U, invalid[index][1]);
|
||
}
|
||
command_send(45U, 6U, 0x51U, 1U, 6002U, 0x81U); command_flush();
|
||
command_reply_at(index++, 45U, 0x47U, 0x51U, 1U, 6002U, 0x81U);
|
||
command_send(45U, 6U, 0x51U, 2U, 6001U, 0x81U); command_flush();
|
||
command_reply_at(index++, 45U, 0x47U, 0x51U, 2U, 6001U, 0x81U);
|
||
CHECK(command_status.dropped_requests == 1U && command_status.busy_rejected == 3U &&
|
||
command_status.rejected == 6U && command_status.overloads == 0U && command_action_calls == 0U);
|
||
command_send(45U, 8U, 0x51U, 1U, 6001U, 0U); command_flush();
|
||
command_reply_at(index++, 45U, 9U, 0x51U, 1U, 6001U, 0U);
|
||
CHECK(command_frame_count() == index && command_status.dropped_requests == 1U);
|
||
finished = command_take(IEC104_COMMAND_FINISHED);
|
||
CHECK(finished.reason == IEC104_COMMAND_FINISH_DEACTIVATED &&
|
||
finished.request.receive_serial == event.request.receive_serial);
|
||
CHECK(IEC104_Slave_Remove_Station(command_slave, &other) == IEC104_STATION_OK);
|
||
command_empty(); command_close(); ++command_checks;
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:同点依据原注册身份及会话。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:删除后未知CA仍回46,同CA替代节点仍属其他点并忙拒绝。
|
||
* STOP/断线终结待决定事务后,相同原文可建立新事务;此前被丢弃的请求不得留下回复或动作。
|
||
*/
|
||
static void test_command_pending_repeat_lifetime(void)
|
||
{
|
||
IEC104_CommandEvent_t event, next, finished;
|
||
IEC104_Station_t replacement = {0};
|
||
unsigned mode;
|
||
command_open(NULL); command_send(45U, 6U, 0x51U, 1U, 6001U, 0x81U);
|
||
event = command_take(IEC104_COMMAND_SELECT);
|
||
CHECK(IEC104_Slave_Remove_Station(command_slave, &command_station) == IEC104_STATION_OK);
|
||
command_send(45U, 6U, 0x51U, 1U, 6001U, 0x81U); command_flush();
|
||
command_reply_at(0U, 45U, 0x6eU, 0x51U, 1U, 6001U, 0x81U);
|
||
CHECK(IEC104_Slave_Add_Station(command_slave, &replacement, 1U, &replacement) == IEC104_STATION_OK);
|
||
command_send(45U, 6U, 0x51U, 1U, 6001U, 0x81U); command_flush();
|
||
command_reply_at(1U, 45U, 0x47U, 0x51U, 1U, 6001U, 0x81U);
|
||
CHECK(command_status.dropped_requests == 0U && command_status.busy_rejected == 1U);
|
||
IEC104_Command_Cancel(command); finished = command_take(IEC104_COMMAND_FINISHED);
|
||
CHECK(finished.reason == IEC104_COMMAND_FINISH_CANCELLED &&
|
||
finished.request.station_id == event.request.station_id && IEC104_Station_Is_Reusable(&command_station));
|
||
command_send(45U, 6U, 0x51U, 1U, 6001U, 0x81U); next = command_take(IEC104_COMMAND_SELECT);
|
||
CHECK(next.request.station_id != event.request.station_id && next.transaction_id != event.transaction_id);
|
||
CHECK(IEC104_Command_Accept(command, &next, command_action, &command_action_calls) == IEC104_COMMAND_REPLY_OK);
|
||
command_flush(); command_reply_at(2U, 45U, 7U, 0x51U, 1U, 6001U, 0x81U);
|
||
CHECK(command_action_calls == 1U && command_frame_count() == 3U);
|
||
CHECK(IEC104_Slave_Remove_Station(command_slave, &replacement) == IEC104_STATION_OK);
|
||
command_close(); CHECK(IEC104_Station_Is_Reusable(&replacement));
|
||
for (mode = 0U; mode < 2U; ++mode) {
|
||
IEC104_CommandConfig_t config;
|
||
IEC104_SlaveEvent_t old_input;
|
||
command_config_default(&config); command_config_mode(&config, IEC104_COMMAND_MODE_DIRECT);
|
||
command_open(&config); command_send(46U, 6U, 0x51U, 1U, 6001U, 2U);
|
||
event = command_take(IEC104_COMMAND_EXECUTE);
|
||
CHECK(IEC104_Slave_Copy_Event(&old_input, &command_last_input));
|
||
command_send(46U, 6U, 0x51U, 1U, 6001U, 2U);
|
||
if (mode == 0U) { push(stop_act, sizeof(stop_act)); }
|
||
else { fake.recv_eof = 1U; }
|
||
command_poll(); finished = command_take(IEC104_COMMAND_FINISHED);
|
||
CHECK(finished.reason == (mode == 0U ? IEC104_COMMAND_FINISH_STOPPED : IEC104_COMMAND_FINISH_DISCONNECTED));
|
||
CHECK(command_action_calls == 0U && command_frame_count() == 0U);
|
||
CHECK(IEC104_Command_Accept(command, &event, command_action, &command_action_calls) == IEC104_COMMAND_REPLY_STALE);
|
||
if (mode == 0U) { push(start_act, sizeof(start_act)); command_poll(); }
|
||
else {
|
||
fake.recv_eof = 0U; command_connect();
|
||
CHECK(IEC104_Command_Handle_Event(command, &old_input) == IEC104_COMMAND_EVENT_IGNORED);
|
||
}
|
||
command_send(46U, 6U, 0x51U, 1U, 6001U, 2U); next = command_take(IEC104_COMMAND_EXECUTE);
|
||
CHECK(next.transaction_id != event.transaction_id);
|
||
CHECK((next.request.generation == event.request.generation) == (mode == 0U));
|
||
CHECK(IEC104_Command_Accept(command, &next, command_action, &command_action_calls) == IEC104_COMMAND_REPLY_OK);
|
||
(void)command_done(&next, IEC104_COMMAND_RESULT_SUCCEEDED);
|
||
CHECK(command_action_calls == 1U && command_frame_count() == 2U && command_status.dropped_requests == 1U);
|
||
command_reply_at(0U, 46U, 7U, 0x51U, 1U, 6001U, 2U);
|
||
command_empty(); command_close();
|
||
}
|
||
++command_checks;
|
||
}
|
||
|
||
/* ============================================================================
|
||
* [COMMAND/LIFETIME] 事务生命周期:FINISHED、撤销、期限、FIFO、会话和站点
|
||
* ============================================================================ */
|
||
/**
|
||
* 功能:验证以下场景与约束:FINISHED配对按事务历史判断:未读SELECT、未读直接EXECUTE不欠终结通知。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:SELECT曾交付后,即使匹配的EXECUTE尚未读,撤销也必须恰好交付一次FINISHED。
|
||
* 撤销不要求命令值相同,DEACT_CON应回显撤销请求自身的值。
|
||
*/
|
||
static void test_command_finished_pairing(void)
|
||
{
|
||
unsigned mode;
|
||
for (mode = 0U; mode < 4U; ++mode) {
|
||
IEC104_CommandConfig_t config;
|
||
IEC104_CommandEvent_t event, finished;
|
||
command_config_default(&config);
|
||
if (mode == 1U) { command_config_mode(&config, IEC104_COMMAND_MODE_DIRECT); }
|
||
command_open(&config);
|
||
if (mode >= 2U) {
|
||
event = command_select(45U, 1U);
|
||
command_send(45U, 6U, 0x51U, 1U, 6001U, 1U);
|
||
} else {
|
||
command_send(45U, 6U, 0x51U, 1U, 6001U, mode == 0U ? 0x81U : 1U);
|
||
}
|
||
if (mode == 3U) { event = command_take(IEC104_COMMAND_EXECUTE); }
|
||
command_send(45U, 8U, 0x51U, 1U, 6001U, 0U); command_flush();
|
||
if (mode < 2U) { command_empty(); }
|
||
else {
|
||
finished = command_take(IEC104_COMMAND_FINISHED);
|
||
CHECK(finished.reason == IEC104_COMMAND_FINISH_DEACTIVATED);
|
||
CHECK(finished.transaction_id == event.transaction_id && finished.select_effect);
|
||
command_empty();
|
||
}
|
||
command_reply_at(mode >= 2U ? 1U : 0U, 45U, 9U, 0x51U, 1U, 6001U, 0U);
|
||
command_close();
|
||
}
|
||
++command_checks;
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:HIGH不足时选择动作尚未执行。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:同OA同点重复激活继续按决定阶段规则静默丢弃。
|
||
* 发送恢复后再Accept,确认接手后匹配执行应成功。
|
||
*/
|
||
static void test_command_unsubmitted_selection(void)
|
||
{
|
||
IEC104_CommandEvent_t selected, executed;
|
||
IEC104_CommandTransactionInfo_t info;
|
||
command_open(NULL);
|
||
command_send(45U, 6U, 0x51U, 1U, 6001U, 0x81U);
|
||
selected = command_take(IEC104_COMMAND_SELECT); command_congest();
|
||
CHECK(IEC104_Command_Accept(command, &selected, command_action, &command_action_calls) == IEC104_COMMAND_REPLY_WAIT);
|
||
command_process();
|
||
CHECK(IEC104_Command_Get_Transaction(command, &selected, &info) && !info.confirm_submitted);
|
||
CHECK(command_action_calls == 0U && command_status.pending_replies == 0U);
|
||
/* 尚未执行选择;同OA同点不同类型激活也不能抢先产生否定确认。 */
|
||
command_send(46U, 6U, 0x51U, 1U, 6001U, 2U);
|
||
CHECK(IEC104_Command_Get_Transaction(command, &selected, &info) && info.active);
|
||
CHECK(info.phase == IEC104_COMMAND_PHASE_SELECT_WAIT);
|
||
fake.send_blocked = 0U; command_flush();
|
||
CHECK(command_status.mismatches == 0U && command_status.busy_rejected == 0U);
|
||
CHECK(command_status.dropped_requests == 1U && command_status.confirm_room_waits == 1U);
|
||
CHECK(IEC104_Command_Accept(command, &selected, command_action, &command_action_calls) == IEC104_COMMAND_REPLY_OK);
|
||
command_flush();
|
||
command_reply_at(0U, 45U, 7U, 0x51U, 1U, 6001U, 0x81U);
|
||
CHECK(command_frame_count() == 1U);
|
||
executed = command_execute(45U, 1U);
|
||
(void)command_done(&executed, IEC104_COMMAND_RESULT_SUCCEEDED);
|
||
CHECK(command_action_calls == 2U);
|
||
command_close(); ++command_checks;
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:应用结束与槽释放分离:先读取撤销FINISHED,但DEACT_CON仍被HIGH背压阻塞。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:事务必须继续占槽,Destroy失败,新选择忙拒绝;确认交接后才允许释放。
|
||
*/
|
||
static void test_command_deactivation_wait(void)
|
||
{
|
||
IEC104_CommandEvent_t event, finished;
|
||
command_open(NULL); command_send(45U, 6U, 0x51U, 1U, 6001U, 0x81U);
|
||
event = command_take(IEC104_COMMAND_SELECT); command_congest();
|
||
command_send(45U, 8U, 0x51U, 1U, 6001U, 0U); command_process();
|
||
finished = command_take(IEC104_COMMAND_FINISHED);
|
||
CHECK(finished.reason == IEC104_COMMAND_FINISH_DEACTIVATED);
|
||
CHECK(IEC104_Command_Get_Status(command, &command_status));
|
||
CHECK(command_status.busy && command_status.pending_replies != 0U);
|
||
CHECK(!IEC104_Command_Destroy(command));
|
||
CHECK(IEC104_Command_Accept(command, &event, command_action, &command_action_calls) == IEC104_COMMAND_REPLY_STALE);
|
||
command_send(45U, 6U, 0x52U, 1U, 6002U, 0x81U);
|
||
fake.send_blocked = 0U; command_flush();
|
||
CHECK(!command_status.busy);
|
||
command_reply_at(0U, 45U, 9U, 0x51U, 1U, 6001U, 0U);
|
||
command_reply_at(1U, 45U, 0x47U, 0x52U, 1U, 6002U, 0x81U);
|
||
command_empty(); command_close();
|
||
++command_checks;
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:决定、选择、执行三种期限分别验证到期前、恰好到期和单调时间倒退。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:不先调用Process,而由Accept、Handle_Event、Report_Result或NextEvent触发检查,
|
||
* 防止过期状态被新的操作复活;关闭持续时长限制仍不能掩盖时钟倒退。
|
||
*/
|
||
static void test_command_deadlines(void)
|
||
{
|
||
unsigned phase, boundary;
|
||
for (phase = 0U; phase < 3U; ++phase) {
|
||
for (boundary = 0U; boundary < 3U; ++boundary) {
|
||
IEC104_CommandConfig_t config;
|
||
IEC104_CommandEvent_t event, finished;
|
||
uint64_t started;
|
||
command_config_default(&config);
|
||
config.decision_timeout_ms = config.select_timeout_ms = config.execute_timeout_ms = 10U;
|
||
command_open(&config);
|
||
if (phase == 0U) {
|
||
command_send(45U, 6U, 0x51U, 1U, 6001U, 0x81U);
|
||
event = command_take(IEC104_COMMAND_SELECT);
|
||
} else {
|
||
event = command_select(45U, 1U);
|
||
if (phase == 2U) { event = command_execute(45U, 1U); command_flush(); }
|
||
}
|
||
started = fake.now;
|
||
if (phase == 1U) {
|
||
uint8_t bytes[10];
|
||
command_bytes(bytes, 45U, 6U, 0x51U, 1U, 6001U, 1U);
|
||
command_queue(bytes, sizeof(bytes));
|
||
CHECK(IEC104_Slave_Poll(command_slave, 0U, NULL) == IEC104_TCP_OK);
|
||
}
|
||
/* 传输接收时保持正常时间,再改变业务受理时刻,隔离链路计时的影响。 */
|
||
fake.now = boundary == 2U ? started - 1U : started + 9U + boundary;
|
||
if (phase == 0U) {
|
||
CHECK(IEC104_Command_Accept(command, &event, command_action, &command_action_calls) ==
|
||
(boundary == 0U ? IEC104_COMMAND_REPLY_OK : IEC104_COMMAND_REPLY_STALE));
|
||
} else if (phase == 1U) {
|
||
command_drain_transport();
|
||
} else {
|
||
CHECK(IEC104_Command_Report_Result(command, &event, IEC104_COMMAND_RESULT_SUCCEEDED) ==
|
||
(boundary == 0U ? IEC104_COMMAND_REPLY_OK : IEC104_COMMAND_REPLY_STALE));
|
||
}
|
||
if (boundary != 0U) {
|
||
finished = command_take(IEC104_COMMAND_FINISHED);
|
||
CHECK(finished.reason == (phase == 0U ? IEC104_COMMAND_FINISH_DECISION_TIMEOUT :
|
||
(phase == 1U ? IEC104_COMMAND_FINISH_SELECT_TIMEOUT : IEC104_COMMAND_FINISH_EXECUTE_TIMEOUT)));
|
||
CHECK(IEC104_Command_Get_Status(command, &command_status));
|
||
CHECK(command_status.clock_errors == (boundary == 2U ? 1U : 0U));
|
||
} else if (phase == 1U) {
|
||
event = command_take(IEC104_COMMAND_EXECUTE); CHECK(event.request.selected);
|
||
}
|
||
fake.now = started + 10U;
|
||
command_close();
|
||
}
|
||
}
|
||
/* 期限配置0仅关闭持续时长限制;单调时钟倒退仍须终结并累计clock_errors。 */
|
||
for (phase = 0U; phase < 2U; ++phase) {
|
||
IEC104_CommandConfig_t config;
|
||
IEC104_CommandEvent_t event, finished;
|
||
command_config_default(&config);
|
||
command_config_mode(&config, IEC104_COMMAND_MODE_DIRECT);
|
||
config.decision_timeout_ms = config.execute_timeout_ms = 0U;
|
||
command_open(&config);
|
||
command_send(45U, 6U, 0x51U, 1U, 6001U, 1U);
|
||
event = command_take(IEC104_COMMAND_EXECUTE);
|
||
if (phase != 0U) {
|
||
CHECK(IEC104_Command_Accept(command, &event, command_action, &command_action_calls) == IEC104_COMMAND_REPLY_OK);
|
||
command_flush();
|
||
}
|
||
--fake.now;
|
||
CHECK(IEC104_Command_Get_Status(command, &command_status));
|
||
CHECK(!command_status.timer_active && command_status.need_process);
|
||
if (phase == 0U) {
|
||
CHECK(IEC104_Command_Accept(command, &event, command_action, &command_action_calls) == IEC104_COMMAND_REPLY_STALE);
|
||
CHECK(command_action_calls == 0U);
|
||
} else {
|
||
CHECK(IEC104_Command_Report_Result(command, &event, IEC104_COMMAND_RESULT_SUCCEEDED) == IEC104_COMMAND_REPLY_STALE);
|
||
}
|
||
finished = command_take(IEC104_COMMAND_FINISHED);
|
||
CHECK(finished.reason == (phase == 0U ? IEC104_COMMAND_FINISH_DECISION_TIMEOUT : IEC104_COMMAND_FINISH_EXECUTE_TIMEOUT));
|
||
CHECK(IEC104_Command_Get_Status(command, &command_status));
|
||
CHECK(command_status.clock_errors == 1U);
|
||
++fake.now;
|
||
command_close();
|
||
}
|
||
/* SELECT已经交付,即使后续EXECUTE尚未读取,决定超时仍欠应用一次FINISHED。 */
|
||
{
|
||
IEC104_CommandConfig_t config;
|
||
IEC104_CommandEvent_t event;
|
||
command_config_default(&config); config.decision_timeout_ms = 10U;
|
||
command_open(&config); (void)command_select(45U, 1U);
|
||
command_send(45U, 6U, 0x51U, 1U, 6001U, 1U); fake.now += 10U;
|
||
event = command_take(IEC104_COMMAND_FINISHED);
|
||
CHECK(event.reason == IEC104_COMMAND_FINISH_DECISION_TIMEOUT);
|
||
command_empty(); command_close();
|
||
}
|
||
++command_checks;
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:确认已接手但k窗口未打开时仍可先报告结果,停止执行计时。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:返回信息同样可先入HIGH,随后逐个ACK推进确认、返回信息、终止。
|
||
*/
|
||
static void test_command_result_before_confirm(void)
|
||
{
|
||
IEC104_CommandConfig_t config;
|
||
IEC104_CommandEvent_t event, finished;
|
||
IEC104_CommandTransactionInfo_t info;
|
||
IEC60870_Asdu_t data;
|
||
uint8_t bytes[10];
|
||
uint8_t filler[] = {200U, 0U, 3U, 0U, 1U, 0U};
|
||
command_config_default(&config); command_config_mode(&config, IEC104_COMMAND_MODE_DIRECT); config.execute_timeout_ms = 10U;
|
||
command_window = 1U; command_open(&config);
|
||
CHECK(IEC60870_Asdu_Create_From_Buffer(&data, IEC104_Slave_Get_Application_Layer_Parameters(command_slave),
|
||
filler, sizeof(filler)) == IEC60870_ASDU_OK);
|
||
CHECK(IEC104_Slave_Enqueue_Event(command_slave, &data) == IEC104_TCP_SUBMIT_OK);
|
||
command_poll(); command_send(45U, 6U, 0x51U, 1U, 6001U, 1U);
|
||
event = command_take(IEC104_COMMAND_EXECUTE);
|
||
CHECK(IEC104_Command_Accept(command, &event, command_action, &command_action_calls) == IEC104_COMMAND_REPLY_OK);
|
||
command_process();
|
||
CHECK(IEC104_Command_Get_Transaction(command, &event, &info) && info.confirm_submitted);
|
||
CHECK(command_frame_count() == 0U);
|
||
CHECK(IEC104_Command_Report_Result(command, &event, IEC104_COMMAND_RESULT_SUCCEEDED) == IEC104_COMMAND_REPLY_OK);
|
||
command_return(&data, bytes, 1U, 1U);
|
||
CHECK(IEC104_Command_Submit_Return_Info(command, &event, &data) == IEC104_COMMAND_REPLY_OK);
|
||
fake.now += 100U; command_process();
|
||
CHECK(command_status.execute_timeouts == 0U && command_action_calls == 1U);
|
||
CHECK(IEC104_Command_Complete(command, &event) == IEC104_COMMAND_REPLY_OK);
|
||
push_ack(1U); command_poll(); command_flush();
|
||
push_ack(2U); command_poll(); command_flush();
|
||
push_ack(3U); command_poll();
|
||
command_flush(); finished = command_take(IEC104_COMMAND_FINISHED);
|
||
CHECK(finished.reason == IEC104_COMMAND_FINISH_COMPLETED && command_frame_count() == 3U);
|
||
command_reply_at(0U, 45U, 7U, 0x51U, 1U, 6001U, 1U);
|
||
command_reply_at(1U, 1U, 11U, 0x51U, 1U, 1001U, 1U);
|
||
command_reply_at(2U, 45U, 10U, 0x51U, 1U, 6001U, 1U);
|
||
command_close(); ++command_checks;
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:全局FIFO与独立应答满池:连续忙请求填满固定槽,多出的新请求丢弃并计数。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:只排空传输缓冲而不推进Command时,Submit_Return_Info仍须等待模块内旧应答,
|
||
* 证明返回信息不能绕过业务FIFO;解除后按原请求OA顺序回包。
|
||
*/
|
||
static void test_command_fifo_and_overload(void)
|
||
{
|
||
IEC104_CommandEvent_t event;
|
||
IEC60870_Asdu_t data;
|
||
uint8_t bytes[10];
|
||
unsigned index;
|
||
command_open(NULL); (void)command_select(45U, 1U); event = command_execute(45U, 1U); command_flush();
|
||
command_congest();
|
||
for (index = 0U; index < IEC104_COMMAND_REPLY_CAPACITY + 2U; ++index) {
|
||
command_send(45U, 6U, 0x60U + index, 1U, 6002U, 0x81U);
|
||
}
|
||
CHECK(IEC104_Command_Get_Status(command, &command_status));
|
||
CHECK(command_status.pending_replies == IEC104_COMMAND_REPLY_CAPACITY);
|
||
CHECK(command_status.overloads == 2U && command_status.dropped_requests == 2U);
|
||
fake.send_blocked = 0U;
|
||
/* 只推进TCP,保留Command队首;底层空闲不能成为返回信息插队的理由。 */
|
||
for (index = 0U; index < 16U; ++index) { command_poll(); }
|
||
command_return(&data, bytes, 1U, 1U);
|
||
CHECK(IEC104_Command_Submit_Return_Info(command, &event, &data) == IEC104_COMMAND_REPLY_WAIT);
|
||
command_flush();
|
||
CHECK(IEC104_Command_Submit_Return_Info(command, &event, &data) == IEC104_COMMAND_REPLY_OK);
|
||
command_poll(); (void)command_done(&event, IEC104_COMMAND_RESULT_SUCCEEDED);
|
||
for (index = 0U; index < IEC104_COMMAND_REPLY_CAPACITY; ++index) {
|
||
command_reply_at(index + 2U, 45U, 0x47U, 0x60U + index, 1U, 6002U, 0x81U);
|
||
}
|
||
command_reply_at(IEC104_COMMAND_REPLY_CAPACITY + 2U, 1U, 11U, 0x51U, 1U, 1001U, 1U);
|
||
command_close(); ++command_checks;
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:返回信息必须完整验证类型、COT、P/N、TEST、CA、对象品质和精确长度。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:错误ASDU不得接手;合法的COT=3及与遥控点不同的监视IOA应可提交。
|
||
*/
|
||
static void test_command_return_validation(void)
|
||
{
|
||
IEC104_CommandEvent_t event;
|
||
IEC60870_Asdu_t object;
|
||
uint8_t bytes[11];
|
||
unsigned index;
|
||
command_open(NULL); (void)command_select(45U, 1U); event = command_execute(45U, 1U); command_flush();
|
||
for (index = 0U; index < 7U; ++index) {
|
||
size_t length = 10U;
|
||
command_bytes(bytes, 1U, 11U, 0x51U, 1U, 1001U, 1U);
|
||
switch (index) {
|
||
case 0U: bytes[0] = 45U; break;
|
||
case 1U: bytes[2] = 5U; break;
|
||
case 2U: bytes[2] |= 0x40U; break;
|
||
case 3U: bytes[2] |= 0x80U; break;
|
||
case 4U: bytes[4] = 2U; break;
|
||
case 5U: bytes[9] = 2U; break;
|
||
default: bytes[10] = 1U; length = 11U; break;
|
||
}
|
||
CHECK(IEC60870_Asdu_Create_From_Buffer(&object,
|
||
IEC104_Slave_Get_Application_Layer_Parameters(command_slave), bytes, length) == IEC60870_ASDU_OK);
|
||
CHECK(IEC104_Command_Submit_Return_Info(command, &event, &object) == IEC104_COMMAND_REPLY_ERROR);
|
||
}
|
||
command_bytes(bytes, 1U, 3U, 0x51U, 1U, 9876U, 0U);
|
||
CHECK(IEC60870_Asdu_Create_From_Buffer(&object,
|
||
IEC104_Slave_Get_Application_Layer_Parameters(command_slave), bytes, 10U) == IEC60870_ASDU_OK);
|
||
CHECK(IEC104_Command_Submit_Return_Info(command, &event, &object) == IEC104_COMMAND_REPLY_OK);
|
||
command_poll(); (void)command_done(&event, IEC104_COMMAND_RESULT_SUCCEEDED);
|
||
command_reply_at(2U, 1U, 3U, 0x51U, 1U, 9876U, 0U);
|
||
command_close(); ++command_checks;
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:STOP/START通知优先于同一时刻的决定超时:未读通知时Accept只返回WAIT且不动作。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:按FIFO消费后,旧事务原因保持STOPPED,重新激活也不能复活旧事件。
|
||
*/
|
||
static void test_command_stop_notifications(void)
|
||
{
|
||
IEC104_CommandConfig_t config;
|
||
IEC104_CommandEvent_t event, finished;
|
||
command_config_default(&config); config.decision_timeout_ms = 10U;
|
||
command_open(&config); command_send(45U, 6U, 0x51U, 1U, 6001U, 0x81U);
|
||
event = command_take(IEC104_COMMAND_SELECT);
|
||
fake.now += 10U;
|
||
push(stop_act, sizeof(stop_act)); push(start_act, sizeof(start_act));
|
||
CHECK(IEC104_Slave_Poll(command_slave, 0U, NULL) == IEC104_TCP_OK);
|
||
CHECK(IEC104_Command_Accept(command, &event, command_action, &command_action_calls) == IEC104_COMMAND_REPLY_WAIT);
|
||
command_process(); CHECK(command_status.events_pending && command_status.decision_timeouts == 0U);
|
||
command_drain_transport();
|
||
finished = command_take(IEC104_COMMAND_FINISHED);
|
||
CHECK(finished.reason == IEC104_COMMAND_FINISH_STOPPED && command_action_calls == 0U);
|
||
command_empty(); CHECK(IEC104_Command_Get_Status(command, &command_status) && command_status.active);
|
||
CHECK(IEC104_Command_Accept(command, &event, command_action, &command_action_calls) == IEC104_COMMAND_REPLY_STALE);
|
||
command_close();
|
||
++command_checks;
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:执行中断线不回滚动作,但必须交付DISCONNECTED并拒绝迟到结果。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:重连后的同点新事务具有新连接代次与事务号,旧令牌不能作用于新输出。
|
||
*/
|
||
static void test_command_disconnect_and_reuse(void)
|
||
{
|
||
IEC104_CommandEvent_t event, next, finished;
|
||
IEC104_CommandConfig_t config;
|
||
uint64_t generation;
|
||
command_config_default(&config); command_config_mode(&config, IEC104_COMMAND_MODE_DIRECT);
|
||
command_open(&config); event = command_execute(45U, 1U); command_flush();
|
||
generation = event.request.generation;
|
||
fake.recv_eof = 1U; command_poll();
|
||
finished = command_take(IEC104_COMMAND_FINISHED);
|
||
CHECK(finished.reason == IEC104_COMMAND_FINISH_DISCONNECTED && finished.execute_effect);
|
||
CHECK(IEC104_Command_Report_Result(command, &event, IEC104_COMMAND_RESULT_SUCCEEDED) == IEC104_COMMAND_REPLY_STALE);
|
||
command_empty(); fake.recv_eof = 0U; command_connect();
|
||
next = command_execute(45U, 1U);
|
||
CHECK(next.request.generation != generation && next.transaction_id != event.transaction_id);
|
||
CHECK(IEC104_Command_Report_Result(command, &event, IEC104_COMMAND_RESULT_SUCCEEDED) == IEC104_COMMAND_REPLY_STALE);
|
||
(void)command_done(&next, IEC104_COMMAND_RESULT_SUCCEEDED); command_close();
|
||
++command_checks;
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:原站点删除、同CA重新注册时,已受理事务仍持原节点,不能匹配替代站点的执行。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:应用在工作事件阶段额外Acquire,保证FINISHED出队并释放模块引用之后仍能清理;
|
||
* 最后一次应用Release才允许旧节点复用。
|
||
*/
|
||
static void test_command_station_lifetime(void)
|
||
{
|
||
IEC104_CommandEvent_t event, finished;
|
||
IEC104_Station_t replacement = {0};
|
||
uint64_t original;
|
||
command_open(NULL); command_send(45U, 6U, 0x51U, 1U, 6001U, 0x81U);
|
||
event = command_take(IEC104_COMMAND_SELECT); original = event.request.station_id;
|
||
CHECK(IEC104_Slave_Acquire_Station(command_slave, &command_station) == IEC104_STATION_OK);
|
||
CHECK(IEC104_Slave_Remove_Station(command_slave, &command_station) == IEC104_STATION_OK);
|
||
CHECK(!IEC104_Station_Is_Reusable(&command_station));
|
||
CHECK(IEC104_Slave_Add_Station(command_slave, &replacement, 1U, &replacement) == IEC104_STATION_OK);
|
||
CHECK(IEC104_Command_Accept(command, &event, command_action, &command_action_calls) == IEC104_COMMAND_REPLY_OK);
|
||
command_flush(); CHECK(command_action_request.station_id == original);
|
||
command_send(45U, 6U, 0x51U, 1U, 6001U, 1U); command_flush();
|
||
CHECK(command_action_calls == 1U && command_status.busy);
|
||
command_reply_at(1U, 45U, 0x47U, 0x51U, 1U, 6001U, 1U);
|
||
IEC104_Command_Cancel(command); finished = command_take(IEC104_COMMAND_FINISHED);
|
||
CHECK(finished.reason == IEC104_COMMAND_FINISH_CANCELLED && finished.request.station_id == original);
|
||
CHECK(IEC104_Slave_Get_Station_By_Id(command_slave, original) == &command_station);
|
||
CHECK(IEC104_Slave_Release_Station(command_slave, &command_station) == IEC104_STATION_OK);
|
||
CHECK(IEC104_Station_Is_Reusable(&command_station));
|
||
CHECK(IEC104_Slave_Remove_Station(command_slave, &replacement) == IEC104_STATION_OK);
|
||
command_close(); ++command_checks;
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:EXECUTE必须提供动作。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:回调重入受测入口不会改变当前事务或触发第二次动作。
|
||
*/
|
||
static void test_command_reentry(void)
|
||
{
|
||
IEC104_CommandConfig_t config;
|
||
command_config_default(&config); command_config_mode(&config, IEC104_COMMAND_MODE_DIRECT);
|
||
command_open(&config); command_send(45U, 6U, 0x51U, 1U, 6001U, 1U);
|
||
command_reentry_event = command_take(IEC104_COMMAND_EXECUTE);
|
||
CHECK(IEC104_Command_Accept(command, &command_reentry_event, NULL, NULL) == IEC104_COMMAND_REPLY_ERROR);
|
||
CHECK(IEC104_Command_Accept(command, &command_reentry_event, command_reentry_action, &command_action_calls) == IEC104_COMMAND_REPLY_OK);
|
||
CHECK(command_action_calls == 1U);
|
||
(void)command_done(&command_reentry_event, IEC104_COMMAND_RESULT_SUCCEEDED);
|
||
command_close(); ++command_checks;
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:将k缩为1,逐帧给出真实主站ACK:选择确认、执行确认、返回信息各占一个窗口。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:HIGH有空间即可接手返回信息,Complete可关闭阶段但TERM仍等待窗口,
|
||
* 最后交接TERM后才交付完成通知,随后按统一生命周期释放资源。
|
||
*/
|
||
static void test_command_window_and_cancel(void)
|
||
{
|
||
IEC104_CommandEvent_t event;
|
||
IEC60870_Asdu_t data;
|
||
uint8_t bytes[10];
|
||
command_window = 1U; command_open(NULL); (void)command_select(45U, 1U);
|
||
event = command_execute(45U, 1U); command_process();
|
||
CHECK(IEC104_Command_Report_Result(command, &event, IEC104_COMMAND_RESULT_SUCCEEDED) == IEC104_COMMAND_REPLY_OK);
|
||
command_return(&data, bytes, 1U, 1U);
|
||
CHECK(IEC104_Command_Submit_Return_Info(command, &event, &data) == IEC104_COMMAND_REPLY_OK);
|
||
CHECK(IEC104_Command_Complete(command, &event) == IEC104_COMMAND_REPLY_OK);
|
||
command_process(); command_empty(); CHECK(command_frame_count() == 1U);
|
||
push_ack(1U); command_poll(); command_flush();
|
||
command_empty(); CHECK(command_frame_count() == 2U);
|
||
push_ack(2U); command_poll(); command_flush();
|
||
command_flush(); CHECK(command_frame_count() == 3U);
|
||
command_empty();
|
||
push_ack(3U); command_poll(); command_flush();
|
||
CHECK(command_take(IEC104_COMMAND_FINISHED).reason == IEC104_COMMAND_FINISH_COMPLETED);
|
||
CHECK(command_frame_count() == 4U); command_close();
|
||
++command_checks;
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:TCP容量至少为2时创建第二个独立Slave,验证实例池可分配且事件归属不串服务。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:外来Slave通知被拒绝,外来工作事件不能触发动作;容量1构建仍保留其余测试。
|
||
*/
|
||
static void test_command_two_services(void)
|
||
{
|
||
#if IEC104_TCP_SERVER_CAPACITY >= 2
|
||
IEC104_Slave_t *other;
|
||
IEC104_Command_t *other_command;
|
||
IEC104_CommandConfig_t config;
|
||
IEC104_SlaveConfig_t service_config;
|
||
IEC104_CommandEvent_t event;
|
||
command_open(NULL);
|
||
other = IEC104_Slave_Create(); CHECK(other != NULL);
|
||
test_transport_config(&service_config);
|
||
CHECK(IEC104_Slave_Init(other, &service_config, NULL) == IEC104_TCP_OK);
|
||
command_config_default(&config);
|
||
other_command = IEC104_Command_Create(other, &config); CHECK(other_command != NULL);
|
||
command_send(45U, 6U, 0x51U, 1U, 6001U, 0x81U);
|
||
event = command_take(IEC104_COMMAND_SELECT);
|
||
CHECK(IEC104_Command_Handle_Event(other_command, &command_last_input) == IEC104_COMMAND_EVENT_ERROR);
|
||
CHECK(IEC104_Command_Accept(other_command, &event, command_action, &command_action_calls) != IEC104_COMMAND_REPLY_OK);
|
||
CHECK(command_action_calls == 0U);
|
||
CHECK(IEC104_Command_Destroy(other_command));
|
||
CHECK(IEC104_Slave_Close(other, NULL) == IEC104_TCP_OK);
|
||
CHECK(IEC104_Slave_Destroy(other, NULL) == IEC104_TCP_OK);
|
||
command_close();
|
||
#endif
|
||
++command_checks;
|
||
}
|
||
|
||
/**
|
||
* 功能:对照NORMAL覆盖行为:先把一条返回信息入NORMAL,再以填充事件将其覆盖。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:返回信息立即由HIGH接手,不等待NORMAL排空;其原文不被覆盖。
|
||
*/
|
||
static void test_command_normal_overwrite(void)
|
||
{
|
||
IEC104_CommandConfig_t config;
|
||
IEC104_CommandEvent_t event;
|
||
IEC60870_Asdu_t object, filler;
|
||
uint8_t bytes[10], fill_bytes[249] = {200, 0, 3, 0, 1, 0};
|
||
unsigned index;
|
||
command_config_default(&config); command_config_mode(&config, IEC104_COMMAND_MODE_DIRECT);
|
||
command_open(&config); event = command_execute(45U, 1U); command_flush();
|
||
command_return(&object, bytes, 1U, 0U);
|
||
CHECK(IEC104_Slave_Enqueue_Event(command_slave, &object) == IEC104_TCP_SUBMIT_OK);
|
||
CHECK(IEC60870_Asdu_Create_From_Buffer(&filler,
|
||
IEC104_Slave_Get_Application_Layer_Parameters(command_slave), fill_bytes, sizeof(fill_bytes)) == IEC60870_ASDU_OK);
|
||
for (index = 0U; index < IEC104_TCP_NORMAL_CAPACITY / sizeof(fill_bytes) + 4U; ++index) {
|
||
CHECK(IEC104_Slave_Enqueue_Event(command_slave, &filler) == IEC104_TCP_SUBMIT_OK);
|
||
}
|
||
command_return(&object, bytes, 1U, 1U);
|
||
CHECK(IEC104_Command_Submit_Return_Info(command, &event, &object) == IEC104_COMMAND_REPLY_OK);
|
||
CHECK(command_frame_count() == 2U);
|
||
command_flush();
|
||
/* NORMAL中的第一条返回信息(值0)已被覆盖;HIGH返回值1仍完整保留。 */
|
||
CHECK(command_frame_count() == 2U);
|
||
command_poll(); (void)command_done(&event, IEC104_COMMAND_RESULT_SUCCEEDED);
|
||
CHECK(command_frame_count() == 3U);
|
||
command_reply_at(1U, 1U, 11U, 0x51U, 1U, 1001U, 1U);
|
||
command_close(); ++command_checks;
|
||
}
|
||
|
||
/**
|
||
* 功能:临时拒绝启停通知准入,让真实STOP停留在传输层,供提交入口再次处理。
|
||
* 输入参数:context——业务回调的测试上下文。
|
||
* 输出参数:无。
|
||
* 返回值:固定返回 0,拒绝本次启停通知准入。
|
||
* 说明:接口保留参数仍按回调签名传入,未使用的参数不参与本辅助函数的处理。
|
||
*/
|
||
static int command_hold_transfer(void *context) { (void)context; return 0; }
|
||
|
||
/**
|
||
* 功能:利用原传输观察者的背压入口保留STOP,随后恢复观察者。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:此时服务仍显示已启动且通知队列为空,下一次提交必须亲自处理STOP竞态。
|
||
*/
|
||
static void command_retain_stop(void)
|
||
{
|
||
IEC104_ConnectionTransferObserver_t observer = sut->connection.transfer_observer;
|
||
IEC104_TcpServerStatus_t status;
|
||
sut->connection.transfer_observer.can_accept = command_hold_transfer;
|
||
push(stop_act, sizeof(stop_act));
|
||
CHECK(IEC104_Slave_Poll(command_slave, 0U, NULL) == IEC104_TCP_OK);
|
||
sut->connection.transfer_observer = observer;
|
||
CHECK(sut->rx_blocked && !sut->connection.receive_batch_pending);
|
||
CHECK(IEC104_Slave_Get_Status(command_slave, &status, NULL) == IEC104_TCP_OK);
|
||
CHECK(status.pending_event_count == 0U && status.connection.data_transfer_started);
|
||
}
|
||
|
||
/**
|
||
* 功能:先真实交付启停通知,再报告观察者失败,构造“已有STOP通知但结果为FATAL”。
|
||
* 输入参数:context——业务回调的测试上下文;state——状态值。
|
||
* 输出参数:无。
|
||
* 返回值:固定返回 0,在已交付通知后向传输层报告观察者失败。
|
||
* 说明:用于区分可以让出的正常STOP与必须立即终结的传输故障。
|
||
*/
|
||
static int command_fail_after_stop(void *context, IEC104_DataTransferState_t state)
|
||
{
|
||
CHECK(Notify_Transfer_State(context, state));
|
||
return 0;
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:容量和会话预检通过后,在动作之后的唯一确认提交入口内才受理STOP。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:正常STOP应等待通知再以STOPPED收尾;注入FATAL则立即记SEND_ERROR,不能降为WAIT。
|
||
* 两种路径都保留副作用事实,并拒绝迟到Report_Result。
|
||
*/
|
||
static void test_command_stop_during_submit(void)
|
||
{
|
||
unsigned fatal;
|
||
for (fatal = 0U; fatal < 2U; ++fatal) {
|
||
IEC104_CommandConfig_t config;
|
||
IEC104_CommandEvent_t event, finished;
|
||
command_config_default(&config); command_config_mode(&config, IEC104_COMMAND_MODE_DIRECT);
|
||
command_open(&config); command_send(45U, 6U, 0x51U, 1U, 6001U, 1U);
|
||
event = command_take(IEC104_COMMAND_EXECUTE);
|
||
command_retain_stop();
|
||
if (fatal) { sut->connection.transfer_observer.notify = command_fail_after_stop; }
|
||
CHECK(IEC104_Command_Accept(command, &event, command_action, &command_action_calls) == IEC104_COMMAND_REPLY_OK);
|
||
CHECK(IEC104_Command_Get_Status(command, &command_status));
|
||
if (fatal) {
|
||
/* 即使已有STOP通知,FATAL仍必须保留发送错误语义,不能当成普通让出。 */
|
||
finished = command_take(IEC104_COMMAND_FINISHED);
|
||
CHECK(finished.reason == IEC104_COMMAND_FINISH_SEND_ERROR);
|
||
sut->connection.transfer_observer.notify = Notify_Transfer_State;
|
||
command_drain_transport();
|
||
} else {
|
||
CHECK(command_status.events_pending && command_status.busy && !command_status.need_process);
|
||
command_drain_transport(); finished = command_take(IEC104_COMMAND_FINISHED);
|
||
CHECK(finished.reason == IEC104_COMMAND_FINISH_STOPPED);
|
||
}
|
||
CHECK(finished.execute_effect && command_action_calls == 1U);
|
||
CHECK(IEC104_Command_Get_Status(command, &command_status) && command_status.pending_replies == 0U);
|
||
CHECK(IEC104_Command_Report_Result(command, &event, IEC104_COMMAND_RESULT_SUCCEEDED) == IEC104_COMMAND_REPLY_STALE);
|
||
command_empty(); command_close();
|
||
}
|
||
++command_checks;
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:无活动事务但仍有独立错误应答时,实例也不能销毁。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:Cancel必须清理该应答池;不会因不存在工作事件而凭空产生FINISHED。
|
||
*/
|
||
static void test_command_independent_reply_lifetime(void)
|
||
{
|
||
command_open(NULL);
|
||
command_send(45U, 6U, 0x51U, 1U, 6001U, 0x81U);
|
||
command_congest();
|
||
/* 取消尚未交付的事务,再制造独立错误应答,隔离应答池自身的生命周期。 */
|
||
IEC104_Command_Cancel(command);
|
||
command_send(45U, 6U, 0x61U, 2U, 6001U, 0x81U);
|
||
CHECK(IEC104_Command_Get_Status(command, &command_status));
|
||
CHECK(!command_status.busy && command_status.pending_replies == 1U);
|
||
CHECK(!IEC104_Command_Destroy(command));
|
||
IEC104_Command_Cancel(command);
|
||
CHECK(IEC104_Command_Get_Status(command, &command_status) && command_status.pending_replies == 0U);
|
||
command_empty(); command_close(); ++command_checks;
|
||
}
|
||
|
||
/* ============================================================================
|
||
* [COMMAND/EXTENDED_HELPERS] 扩展命令辅助:47–51的值、原文请求与回显
|
||
* ============================================================================ */
|
||
/* 新增类型输入仍用独立的手工字节,不调用被测公共编码器生成期望结果。
|
||
* qualifier_offset为255表示没有限定词;状态类的状态位位于限定词中。 */
|
||
static const struct {
|
||
unsigned type;
|
||
size_t payload_length;
|
||
unsigned qualifier_offset;
|
||
uint8_t payload[5];
|
||
} command_value_cases[] = {
|
||
{47U, 1U, 0U, {0x0dU, 0U, 0U, 0U, 0U}},
|
||
{48U, 3U, 2U, {0xc7U, 0xcfU, 0U, 0U, 0U}},
|
||
{49U, 3U, 2U, {0U, 0x80U, 0U, 0U, 0U}},
|
||
{50U, 5U, 4U, {0U, 0U, 0xa0U, 0xbfU, 0U}},
|
||
{51U, 4U, 255U, {0xd5U, 0xaaU, 0x80U, 0xffU, 0U}}
|
||
};
|
||
|
||
/**
|
||
* 功能:拼接手工 ASDU 公共头与给定原始值载荷,返回生成报文的长度。
|
||
* 输入参数:bytes——报文字节缓冲区;type——协议类型或期望事件类型;cause——完整传送原因字节;oa——发起者地址;ca——公共地址;ioa——信息对象地址;payload——原始对象载荷(只读);payload_length——载荷字节数。
|
||
* 输出参数:bytes——写入或读出的数据字节。
|
||
* 返回值:生成报文或结果数据的实际字节长度。
|
||
* 说明:输出缓冲由用例提供至少32字节;当前控制族值载荷最多12字节。
|
||
* 只拼接手工公共头和调用者给定的原始载荷,供基础/时标命令共用。
|
||
*/
|
||
static size_t command_payload_bytes(uint8_t *bytes, unsigned type, unsigned cause,
|
||
unsigned oa, unsigned ca, unsigned ioa, const uint8_t *payload, size_t payload_length)
|
||
{
|
||
CHECK(payload != NULL && payload_length > 0U && payload_length <= 12U);
|
||
command_bytes(bytes, type, cause, oa, ca, ioa, 0U);
|
||
memcpy(bytes + 9U, payload, payload_length);
|
||
return 9U + payload_length;
|
||
}
|
||
|
||
/**
|
||
* 功能:接收一条任意长度的手工ASDU并分派通知,容许用例送入畸形长度以检查校验顺序。
|
||
* 输入参数:bytes——报文字节缓冲区(只读);length——字节长度。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:本辅助入口用于构造或核对上述测试场景,相关状态保存在当前测试夹具中。
|
||
*/
|
||
static void command_raw_send(const uint8_t *bytes, size_t length)
|
||
{
|
||
command_queue(bytes, length);
|
||
command_poll();
|
||
}
|
||
|
||
/**
|
||
* 功能:请求可含SQ或尾部错误,length由用例显式指定期望规范回复长度。
|
||
* 输入参数:index——待访问或核对的条目下标;request——当前业务请求(只读);length——字节长度;cause——完整传送原因字节。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:完整比较保证没有截断浮点/时标,也没有携带上一条长回复的尾部。
|
||
*/
|
||
static void command_raw_reply_at(unsigned index, const uint8_t *request, size_t length, unsigned cause)
|
||
{
|
||
const uint8_t *frames[64];
|
||
size_t lengths[64];
|
||
uint8_t expected[32];
|
||
CHECK(length <= sizeof(expected));
|
||
CHECK(command_collect(frames, lengths) > index);
|
||
memcpy(expected, request, length);
|
||
expected[1] = 1U;
|
||
expected[2] = (uint8_t)cause;
|
||
CHECK(lengths[index] == length);
|
||
CHECK(memcmp(frames[index], expected, length) == 0);
|
||
}
|
||
|
||
/**
|
||
* 功能:对照固定输入值表检查应用事件的解码值及限定词。
|
||
* 输入参数:request——当前业务请求(只读);type——协议类型或期望事件类型。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:比特串族没有S/E字段,必须保持直接执行。
|
||
*/
|
||
static void command_check_value(const IEC104_CommandRequest_t *request, unsigned type)
|
||
{
|
||
CHECK(request->type_id == type);
|
||
switch (type) {
|
||
case 47U: case 58U: case 60U: CHECK(request->state == 1U && request->qualifier == 3U); break;
|
||
case 59U: CHECK(request->state == 2U && request->qualifier == 3U); break;
|
||
case 48U: case 61U: CHECK(request->value.normalized == -12345 && request->qualifier == 0U); break;
|
||
case 49U: case 62U: CHECK(request->value.scaled == -32768 && request->qualifier == 0U); break;
|
||
case 50U: case 63U: CHECK(request->value.short_float == -1.25f && request->qualifier == 0U); break;
|
||
default:
|
||
CHECK((type == 51U || type == 64U) && request->value.bitstring == UINT32_C(0xff80aad5));
|
||
CHECK(request->qualifier == 0U && !request->is_select);
|
||
break;
|
||
}
|
||
}
|
||
|
||
/* ============================================================================
|
||
* [COMMAND/EXTENDED] 扩展命令用例:类型配置、流程、匹配、非法值与变长回复
|
||
* ============================================================================ */
|
||
/**
|
||
* 功能:验证以下场景与约束:可配置的类型与默认启用集合分开验证。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:无S/E的比特串不能要求先选择。
|
||
*/
|
||
static void test_command_extended_configuration(void)
|
||
{
|
||
static const IEC104_CommandPoint_t invalid = {1U, 6001U,
|
||
IEC104_COMMAND_TYPE_BIT(51U), IEC104_COMMAND_MODE_SELECT_EXECUTE};
|
||
IEC104_CommandConfig_t config;
|
||
unsigned type;
|
||
command_open(NULL);
|
||
CHECK(IEC104_Command_Destroy(command));
|
||
for (type = 47U; type <= 51U; ++type) {
|
||
command_config_default(&config);
|
||
config.type_mask = IEC104_COMMAND_TYPE_BIT(type);
|
||
command_config_mode(&config, type == 51U ? IEC104_COMMAND_MODE_DIRECT : IEC104_COMMAND_MODE_SELECT_EXECUTE);
|
||
command = IEC104_Command_Create(command_slave, &config);
|
||
CHECK(command != NULL && IEC104_Command_Destroy(command));
|
||
}
|
||
config.points = &invalid;
|
||
config.point_count = 1U;
|
||
CHECK(IEC104_Command_Create(command_slave, &config) == NULL);
|
||
command_config_default(&config);
|
||
CHECK(config.type_mask == UINT16_C(0x3fff));
|
||
command = IEC104_Command_Create(command_slave, &config);
|
||
CHECK(command != NULL);
|
||
command_close();
|
||
++command_checks;
|
||
}
|
||
|
||
/**
|
||
* 功能:逐类型完成选择/执行/结果/终止。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:51直接执行,且首个值字节bit7=1不能误判选择。
|
||
* 应用改写事件副本的数值后,动作和FINISHED仍须取自模块保存的原请求。
|
||
*/
|
||
static void test_command_extended_flows(void)
|
||
{
|
||
size_t index;
|
||
for (index = 0U; index < sizeof(command_value_cases) / sizeof(command_value_cases[0]); ++index) {
|
||
IEC104_CommandConfig_t config;
|
||
IEC104_CommandEvent_t event, finished;
|
||
uint8_t bytes[32], selected[32], payload[5];
|
||
size_t length;
|
||
unsigned type = command_value_cases[index].type;
|
||
unsigned preceding = type == 51U ? 0U : 1U;
|
||
command_config_default(&config);
|
||
config.type_mask = IEC104_COMMAND_TYPE_BIT(type);
|
||
command_config_mode(&config, type == 51U ? IEC104_COMMAND_MODE_DIRECT : IEC104_COMMAND_MODE_SELECT_EXECUTE);
|
||
command_open(&config);
|
||
memcpy(payload, command_value_cases[index].payload, sizeof(payload));
|
||
length = command_payload_bytes(bytes, type, 6U, 0x51U, 1U, 6001U,
|
||
payload, command_value_cases[index].payload_length);
|
||
if (type != 51U) {
|
||
memcpy(selected, bytes, length);
|
||
selected[9U + command_value_cases[index].qualifier_offset] |= 0x80U;
|
||
command_raw_send(selected, length);
|
||
event = command_take(IEC104_COMMAND_SELECT);
|
||
command_check_value(&event.request, type);
|
||
CHECK(event.request.is_select && !event.request.selected);
|
||
CHECK(IEC104_Command_Accept(command, &event, NULL, NULL) == IEC104_COMMAND_REPLY_OK);
|
||
command_flush();
|
||
command_raw_reply_at(0U, selected, length, 7U);
|
||
}
|
||
command_raw_send(bytes, length);
|
||
event = command_take(IEC104_COMMAND_EXECUTE);
|
||
command_check_value(&event.request, type);
|
||
CHECK(!event.request.is_select && event.request.selected == (type != 51U));
|
||
event.request.value.bitstring = 0U;
|
||
event.request.state = 0U;
|
||
event.request.qualifier = 0U;
|
||
CHECK(IEC104_Command_Accept(command, &event, command_action, &command_action_calls) == IEC104_COMMAND_REPLY_OK);
|
||
CHECK(command_action_calls == 1U);
|
||
command_check_value(&command_action_request, type);
|
||
finished = command_done(&event, IEC104_COMMAND_RESULT_SUCCEEDED);
|
||
command_check_value(&finished.request, type);
|
||
command_raw_reply_at(preceding, bytes, length, 7U);
|
||
command_raw_reply_at(preceding + 1U, bytes, length, 10U);
|
||
CHECK(command_frame_count() == preceding + 2U);
|
||
command_close();
|
||
}
|
||
++command_checks;
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:改变值或合法QU必须结束原选择,否定回显本次执行。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:非法QL只独立拒绝。
|
||
* 短浮点的+0和-0作为不同线上位模式处理,避免改成浮点数值相等比较。
|
||
*/
|
||
static void test_command_extended_matching(void)
|
||
{
|
||
size_t index;
|
||
unsigned variant;
|
||
for (index = 0U; index < 4U; ++index) {
|
||
for (variant = 0U; variant < 2U; ++variant) {
|
||
IEC104_CommandConfig_t config;
|
||
IEC104_CommandEvent_t event, finished;
|
||
uint8_t selected[32], executed[32];
|
||
size_t length;
|
||
unsigned type = command_value_cases[index].type;
|
||
unsigned qualifier = 9U + command_value_cases[index].qualifier_offset;
|
||
command_config_default(&config);
|
||
config.type_mask = IEC104_COMMAND_TYPE_BIT(type);
|
||
command_open(&config);
|
||
length = command_payload_bytes(executed, type, 6U, 0x51U, 1U, 6001U,
|
||
command_value_cases[index].payload, command_value_cases[index].payload_length);
|
||
memcpy(selected, executed, length);
|
||
selected[qualifier] |= 0x80U;
|
||
command_raw_send(selected, length);
|
||
event = command_take(IEC104_COMMAND_SELECT);
|
||
CHECK(IEC104_Command_Accept(command, &event, NULL, NULL) == IEC104_COMMAND_REPLY_OK);
|
||
command_flush();
|
||
if (variant == 0U) { executed[9] ^= type == 47U ? 3U : 1U; }
|
||
else { executed[qualifier] ^= type == 47U ? 4U : 1U; }
|
||
command_raw_send(executed, length);
|
||
command_flush();
|
||
if (variant != 0U && type != 47U) {
|
||
IEC104_CommandTransactionInfo_t info;
|
||
CHECK(IEC104_Command_Get_Transaction(command, &event, &info) && info.active &&
|
||
info.phase == IEC104_COMMAND_PHASE_SELECTED);
|
||
} else {
|
||
finished = command_take(IEC104_COMMAND_FINISHED);
|
||
CHECK(finished.reason == IEC104_COMMAND_FINISH_MISMATCH);
|
||
command_check_value(&finished.request, type);
|
||
}
|
||
CHECK(command_action_calls == 0U);
|
||
command_raw_reply_at(1U, executed, length, 0x47U);
|
||
command_empty();
|
||
command_close();
|
||
}
|
||
}
|
||
{
|
||
IEC104_CommandConfig_t config;
|
||
IEC104_CommandEvent_t event, finished;
|
||
uint8_t selected[32], executed[32];
|
||
static const uint8_t plus_zero[] = {0U, 0U, 0U, 0U, 0x80U};
|
||
static const uint8_t minus_zero[] = {0U, 0U, 0U, 0x80U, 0U};
|
||
size_t length;
|
||
command_config_default(&config);
|
||
config.type_mask = IEC104_COMMAND_TYPE_BIT(50U);
|
||
command_open(&config);
|
||
length = command_payload_bytes(selected, 50U, 6U, 0x51U, 1U, 6001U, plus_zero, sizeof(plus_zero));
|
||
command_raw_send(selected, length);
|
||
event = command_take(IEC104_COMMAND_SELECT);
|
||
CHECK(IEC104_Command_Accept(command, &event, NULL, NULL) == IEC104_COMMAND_REPLY_OK);
|
||
command_flush();
|
||
CHECK(command_payload_bytes(executed, 50U, 6U, 0x51U, 1U, 6001U, minus_zero, sizeof(minus_zero)) == length);
|
||
command_raw_send(executed, length);
|
||
command_flush();
|
||
finished = command_take(IEC104_COMMAND_FINISHED);
|
||
CHECK(finished.reason == IEC104_COMMAND_FINISH_MISMATCH && command_action_calls == 0U);
|
||
command_raw_reply_at(1U, executed, length, 0x47U);
|
||
command_empty();
|
||
command_close();
|
||
}
|
||
++command_checks;
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:RCS保留状态和浮点NaN/Inf必须否定,完整非法值原样回显,不经合法对象重编码。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。
|
||
*/
|
||
static void test_command_extended_invalid_values(void)
|
||
{
|
||
static const uint8_t values[][5] = {
|
||
{0U, 0U, 0U, 0U, 0U}, {3U, 0U, 0U, 0U, 0U},
|
||
{0U, 0U, 0x80U, 0x7fU, 0x55U}, {0U, 0U, 0x80U, 0xffU, 0x55U},
|
||
{0U, 0U, 0xc0U, 0x7fU, 0x55U}, {1U, 0U, 0x80U, 0x7fU, 0x55U}
|
||
};
|
||
size_t index;
|
||
for (index = 0U; index < sizeof(values) / sizeof(values[0]); ++index) {
|
||
IEC104_CommandConfig_t config;
|
||
uint8_t bytes[32];
|
||
size_t length;
|
||
unsigned type = index < 2U ? 47U : 50U;
|
||
command_config_default(&config);
|
||
config.type_mask = IEC104_COMMAND_TYPE_BIT(type);
|
||
command_config_mode(&config, IEC104_COMMAND_MODE_DIRECT);
|
||
command_open(&config);
|
||
length = command_payload_bytes(bytes, type, 6U, 0x61U, 1U, 6001U, values[index], index < 2U ? 1U : 5U);
|
||
command_raw_send(bytes, length);
|
||
command_flush();
|
||
CHECK(command_frame_count() == 1U && command_action_calls == 0U);
|
||
command_raw_reply_at(0U, bytes, length, 0x47U);
|
||
CHECK(command_status.rejected == 1U && !command_status.busy);
|
||
command_empty();
|
||
command_close();
|
||
}
|
||
++command_checks;
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:每种新增长度都检查COT/CA/IOA优先级、SQ/尾部规范回复和缺失完整对象时丢弃。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:TEST/P/N只改变应答原因及标志,不得改变原命令值或启动动作。
|
||
*/
|
||
static void test_command_extended_wire_validation(void)
|
||
{
|
||
size_t index;
|
||
unsigned variant;
|
||
for (index = 0U; index < sizeof(command_value_cases) / sizeof(command_value_cases[0]); ++index) {
|
||
for (variant = 0U; variant < 10U; ++variant) {
|
||
IEC104_CommandConfig_t config;
|
||
uint8_t bytes[32];
|
||
size_t length, received;
|
||
unsigned expected = 0x47U;
|
||
command_config_default(&config);
|
||
config.type_mask = IEC104_COMMAND_TYPE_BIT(command_value_cases[index].type);
|
||
command_config_mode(&config, IEC104_COMMAND_MODE_DIRECT);
|
||
command_open(&config);
|
||
length = command_payload_bytes(bytes, command_value_cases[index].type, 6U, 0x62U, 1U, 6001U,
|
||
command_value_cases[index].payload, command_value_cases[index].payload_length);
|
||
received = length;
|
||
switch (variant) {
|
||
case 0U: bytes[2] = 5U; bytes[4] = 2U; bytes[6] = bytes[7] = bytes[8] = 0U; expected = 0x6dU; break;
|
||
case 1U: bytes[4] = 2U; bytes[6] = bytes[7] = bytes[8] = 0U; expected = 0x6eU; break;
|
||
case 2U: bytes[6] = bytes[7] = bytes[8] = 0U; expected = 0x6fU; break;
|
||
case 3U: bytes[1] = 0x81U; break;
|
||
case 4U: bytes[received++] = 0xa5U; break;
|
||
case 5U: bytes[2] |= 0x40U; break;
|
||
case 6U: bytes[2] |= 0x80U; expected = 0x87U; break;
|
||
case 7U: --received; expected = 0U; break;
|
||
case 8U: bytes[1] = 0U; expected = 0U; break;
|
||
default:
|
||
memcpy(bytes + length, bytes + 6U, length - 6U);
|
||
received += length - 6U;
|
||
bytes[1] = 2U;
|
||
expected = 0U;
|
||
break;
|
||
}
|
||
command_raw_send(bytes, received);
|
||
command_flush();
|
||
CHECK(command_frame_count() == (expected == 0U ? 0U : (variant == 6U ? 2U : 1U)));
|
||
if (expected != 0U) { command_raw_reply_at(0U, bytes, length, expected); }
|
||
if (variant == 6U) { command_raw_reply_at(1U, bytes, length, 0x8aU); }
|
||
CHECK(command_action_calls == 0U && !command_status.busy);
|
||
command_empty();
|
||
command_close();
|
||
}
|
||
}
|
||
++command_checks;
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:长请求被另一类型同点执行终结时,回复长度属于新请求,FINISHED仍属于原选择。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:等待发送期间请求、事务回复及独立回复池同时持有不同长度的原文。
|
||
*/
|
||
static void test_command_extended_reply_lengths(void)
|
||
{
|
||
IEC104_CommandConfig_t config;
|
||
IEC104_CommandEvent_t event, finished;
|
||
uint8_t selected[32], executed[32], short_reply[32];
|
||
static const uint8_t selected_payload[] = {0U, 0U, 0xa0U, 0xbfU, 0x80U};
|
||
static const uint8_t executed_payload[] = {0U, 0x80U, 0U};
|
||
static const uint8_t short_payload[] = {0x81U};
|
||
size_t selected_length, executed_length, short_length;
|
||
command_config_default(&config);
|
||
config.type_mask = IEC104_COMMAND_TYPE_BIT(45U) | IEC104_COMMAND_TYPE_BIT(49U) | IEC104_COMMAND_TYPE_BIT(50U);
|
||
command_config_mode(&config, IEC104_COMMAND_MODE_SELECT_EXECUTE);
|
||
command_open(&config);
|
||
selected_length = command_payload_bytes(selected, 50U, 6U, 0x51U, 1U, 6001U,
|
||
selected_payload, sizeof(selected_payload));
|
||
command_raw_send(selected, selected_length);
|
||
event = command_take(IEC104_COMMAND_SELECT);
|
||
CHECK(IEC104_Command_Accept(command, &event, NULL, NULL) == IEC104_COMMAND_REPLY_OK);
|
||
command_flush();
|
||
command_congest();
|
||
short_length = command_payload_bytes(short_reply, 45U, 6U, 0x61U, 1U, 6002U,
|
||
short_payload, sizeof(short_payload));
|
||
command_raw_send(short_reply, short_length);
|
||
executed_length = command_payload_bytes(executed, 49U, 6U, 0x51U, 1U, 6001U,
|
||
executed_payload, sizeof(executed_payload));
|
||
command_raw_send(executed, executed_length);
|
||
command_process();
|
||
CHECK(command_status.pending_replies == 2U);
|
||
finished = command_take(IEC104_COMMAND_FINISHED);
|
||
CHECK(finished.reason == IEC104_COMMAND_FINISH_MISMATCH);
|
||
CHECK(finished.request.type_id == 50U && finished.request.value.short_float == -1.25f);
|
||
CHECK(command_action_calls == 0U);
|
||
fake.send_blocked = 0U;
|
||
command_flush();
|
||
command_raw_reply_at(0U, selected, selected_length, 7U);
|
||
command_raw_reply_at(1U, short_reply, short_length, 0x47U);
|
||
command_raw_reply_at(2U, executed, executed_length, 0x47U);
|
||
CHECK(command_frame_count() == 3U && !command_status.busy);
|
||
command_empty();
|
||
command_close();
|
||
++command_checks;
|
||
}
|
||
|
||
/* ============================================================================
|
||
* [COMMAND/TIMED_HELPERS] 带时标辅助:58–64请求及CP56/基准配置
|
||
* ============================================================================ */
|
||
/* UTC 2026-01-01 00:00:00.000;日期和期望纪元毫秒独立固定,不用被测转换器算期望。 */
|
||
static const uint64_t command_epoch_ms = UINT64_C(1767225600000);
|
||
static const uint8_t command_epoch_time[7] = {0U, 0U, 0U, 0U, 1U, 1U, 26U};
|
||
static const struct {
|
||
unsigned type;
|
||
size_t payload_length;
|
||
unsigned qualifier_offset;
|
||
uint8_t payload[5];
|
||
} command_timed_cases[] = {
|
||
{58U, 1U, 0U, {0x0dU, 0U, 0U, 0U, 0U}},
|
||
{59U, 1U, 0U, {0x0eU, 0U, 0U, 0U, 0U}},
|
||
{60U, 1U, 0U, {0x0dU, 0U, 0U, 0U, 0U}},
|
||
{61U, 3U, 2U, {0xc7U, 0xcfU, 0U, 0U, 0U}},
|
||
{62U, 3U, 2U, {0U, 0x80U, 0U, 0U, 0U}},
|
||
{63U, 5U, 4U, {0U, 0U, 0xa0U, 0xbfU, 0U}},
|
||
{64U, 4U, 255U, {0xd5U, 0xaaU, 0x80U, 0xffU, 0U}}
|
||
};
|
||
|
||
/**
|
||
* 功能:值载荷后原样附加7字节CP56。
|
||
* 输入参数:bytes——报文字节缓冲区;type——协议类型或期望事件类型;cause——完整传送原因字节;oa——发起者地址;ca——公共地址;ioa——信息对象地址;value——测试对象值或原始位模式(只读);value_length——对象值字节数;time_bytes——原始 CP56Time2a 七字节(只读)。
|
||
* 输出参数:bytes——写入或读出的数据字节。
|
||
* 返回值:生成报文或结果数据的实际字节长度。
|
||
* 说明:不校验时间内容,以便非法月份、IV和边界时间仍可送入待测模块。
|
||
*/
|
||
static size_t command_timed_bytes(uint8_t *bytes, unsigned type, unsigned cause,
|
||
unsigned oa, unsigned ca, unsigned ioa, const uint8_t *value, size_t value_length,
|
||
const uint8_t time_bytes[7])
|
||
{
|
||
uint8_t payload[12];
|
||
CHECK(value_length >= 1U && value_length <= 5U);
|
||
memcpy(payload, value, value_length);
|
||
memcpy(payload + value_length, time_bytes, 7U);
|
||
return command_payload_bytes(bytes, type, cause, oa, ca, ioa, payload, value_length + 7U);
|
||
}
|
||
|
||
/**
|
||
* 功能:只开放本例目标类型,按UTC解释手工时标。
|
||
* 输入参数:config——测试配置对象;type——协议类型或期望事件类型;maximum——最大允许时间偏差(毫秒)。
|
||
* 输出参数:config——测试配置对象。
|
||
* 返回值:无。
|
||
* 说明:maximum=0用于明确关闭时效检查的对照路径。
|
||
*/
|
||
static void command_timed_config(IEC104_CommandConfig_t *config, unsigned type, uint32_t maximum)
|
||
{
|
||
IEC104_Command_Config_Default(config);
|
||
config->type_mask = IEC104_COMMAND_TYPE_BIT(type);
|
||
command_config_mode(config, IEC104_COMMAND_MODE_DIRECT);
|
||
config->time_tag_max_delay_ms = maximum;
|
||
config->master_utc_offset_minutes = 0;
|
||
}
|
||
|
||
/**
|
||
* 功能:验证应用可用48或49拒绝普通及带时标命令的选择、执行事件,并完整回显请求。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:非法原因不能消费事件;有效拒绝只产生一次结束通知,不执行动作,也不计作自动时间校验失败。
|
||
*/
|
||
static void test_command_application_reject_causes(void)
|
||
{
|
||
static const IEC104_CommandRejectCause_t causes[] = {
|
||
IEC104_COMMAND_REJECT_INTERLOCK, IEC104_COMMAND_REJECT_TIME
|
||
};
|
||
unsigned cause_index, timed, selecting;
|
||
CHECK(IEC104_COMMAND_REJECT_INTERLOCK == 3 && IEC104_COMMAND_REJECT_TIME == 4);
|
||
for (cause_index = 0U; cause_index < 2U; ++cause_index) {
|
||
for (timed = 0U; timed < 2U; ++timed) {
|
||
for (selecting = 0U; selecting < 2U; ++selecting) {
|
||
IEC104_CommandConfig_t config;
|
||
IEC104_CommandEvent_t event, finished;
|
||
uint8_t bytes[32], payload = selecting ? 0x81U : 1U;
|
||
unsigned type = timed ? 58U : 45U;
|
||
size_t length;
|
||
command_timed_config(&config, type, 1000U);
|
||
command_config_mode(&config, selecting ? IEC104_COMMAND_MODE_SELECT_EXECUTE : IEC104_COMMAND_MODE_DIRECT);
|
||
command_open(&config);
|
||
CHECK(IEC104_Command_Set_Time_Base(command, command_epoch_ms, fake.now));
|
||
length = timed ? command_timed_bytes(bytes, type, 6U, 0x6aU, 1U, 6001U,
|
||
&payload, 1U, command_epoch_time) : command_payload_bytes(bytes, type, 6U,
|
||
0x6aU, 1U, 6001U, &payload, 1U);
|
||
command_raw_send(bytes, length);
|
||
event = command_take(selecting ? IEC104_COMMAND_SELECT : IEC104_COMMAND_EXECUTE);
|
||
CHECK(IEC104_Command_Reject(command, &event, (IEC104_CommandRejectCause_t)5) == IEC104_COMMAND_REPLY_ERROR);
|
||
CHECK(IEC104_Command_Reject(command, &event, causes[cause_index]) == IEC104_COMMAND_REPLY_OK);
|
||
CHECK(IEC104_Command_Reject(command, &event, causes[cause_index]) == IEC104_COMMAND_REPLY_STALE);
|
||
CHECK(IEC104_Command_Accept(command, &event, command_action, &command_action_calls) == IEC104_COMMAND_REPLY_STALE);
|
||
command_flush();
|
||
command_raw_reply_at(0U, bytes, length, cause_index == 0U ? 0x70U : 0x71U);
|
||
CHECK(command_frame_count() == 1U && command_action_calls == 0U);
|
||
CHECK(command_status.app_rejected == 1U && command_status.negative_submitted == 1U);
|
||
CHECK(command_status.time_rejected == 0U && command_status.time_expired == 0U);
|
||
CHECK(command_status.action_time_rejected == 0U && command_status.action_time_expired == 0U);
|
||
finished = command_take(IEC104_COMMAND_FINISHED);
|
||
CHECK(finished.reason == IEC104_COMMAND_FINISH_REJECTED &&
|
||
finished.transaction_id == event.transaction_id);
|
||
CHECK(!finished.select_effect && !finished.execute_effect && finished.request.has_time == (timed != 0U));
|
||
if (timed) { CHECK(finished.request.time_utc_ms == command_epoch_ms); }
|
||
command_empty(); command_flush();
|
||
CHECK(!command_status.busy && command_frame_count() == 1U);
|
||
command_close();
|
||
}
|
||
}
|
||
}
|
||
++command_checks;
|
||
}
|
||
|
||
/* ============================================================================
|
||
* [COMMAND/QUALIFIERS] QU/QL边界及非法限定词与既有事务隔离
|
||
* ============================================================================ */
|
||
/**
|
||
* 功能:限定词专项独立构造合法状态/数值和CP56,只改变QU或QL。
|
||
* 输入参数:bytes——报文字节缓冲区;type——协议类型或期望事件类型;cause——完整传送原因字节;qualifier——原始限定词;selecting——是否构造选择阶段。
|
||
* 输出参数:bytes——写入或读出的数据字节。
|
||
* 返回值:生成报文或结果数据的实际字节长度。
|
||
* 说明:51/64没有该字段,已由完整比特串流程覆盖;不能把其数据高位拿来作限定词。
|
||
*/
|
||
static size_t command_qualified_bytes(uint8_t *bytes, unsigned type, unsigned cause,
|
||
unsigned qualifier, bool selecting)
|
||
{
|
||
uint8_t payload[5] = {0U};
|
||
unsigned base_type = type >= 58U ? type - 13U : type;
|
||
size_t payload_length = base_type <= 47U ? 1U : (base_type <= 49U ? 3U : 5U);
|
||
if (base_type <= 47U) { payload[0] = (uint8_t)(1U | (qualifier << 2)); }
|
||
else { payload[payload_length - 1U] = (uint8_t)qualifier; }
|
||
if (selecting) { payload[payload_length - 1U] |= 0x80U; }
|
||
return type >= 58U ? command_timed_bytes(bytes, type, cause, 0x51U, 1U, 6001U,
|
||
payload, payload_length, command_epoch_time) : command_payload_bytes(bytes, type, cause,
|
||
0x51U, 1U, 6001U, payload, payload_length);
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:十二种有QU/QL类型均从真实接收路径验证:QU=0..3可交应用、4..31逐值拒绝,
|
||
* 含此前报告的9..15。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:QL只接受0,所列预定义/保留/私有范围值均否定。
|
||
* 合法激活真正调用一次action,非法值无业务事件;已知点撤销无匹配事务回否定9,
|
||
* 完整原文(含限定词)回显。公共编解码允许完整位域,不等于业务支持所有值。
|
||
*/
|
||
static void test_command_qualifier_boundaries(void)
|
||
{
|
||
static const unsigned types[] = {45U, 46U, 47U, 48U, 49U, 50U, 58U, 59U, 60U, 61U, 62U, 63U};
|
||
static const unsigned ql[] = {0U, 1U, 17U, 37U, 64U, 127U};
|
||
size_t type_index, value_index;
|
||
unsigned cause;
|
||
for (type_index = 0U; type_index < sizeof(types) / sizeof(types[0]); ++type_index) {
|
||
unsigned type = types[type_index];
|
||
bool status_command = type <= 47U || (type >= 58U && type <= 60U);
|
||
size_t count = status_command ? 32U : sizeof(ql) / sizeof(ql[0]);
|
||
for (value_index = 0U; value_index < count; ++value_index) {
|
||
unsigned qualifier = status_command ? (unsigned)value_index : ql[value_index];
|
||
for (cause = 6U; cause <= 8U; cause += 2U) {
|
||
IEC104_CommandConfig_t config;
|
||
uint8_t bytes[32];
|
||
size_t length;
|
||
bool legal = status_command ? qualifier <= 3U : qualifier == 0U;
|
||
command_timed_config(&config, type, 0U);
|
||
command_open(&config);
|
||
length = command_qualified_bytes(bytes, type, cause, qualifier, false);
|
||
command_raw_send(bytes, length);
|
||
if (legal && cause == 6U) {
|
||
IEC104_CommandEvent_t event = command_take(IEC104_COMMAND_EXECUTE);
|
||
CHECK(event.request.qualifier == qualifier);
|
||
CHECK(IEC104_Command_Accept(command, &event, command_action,
|
||
&command_action_calls) == IEC104_COMMAND_REPLY_OK);
|
||
(void)command_done(&event, IEC104_COMMAND_RESULT_SUCCEEDED);
|
||
CHECK(command_action_calls == 1U && command_status.rejected == 0U);
|
||
command_raw_reply_at(0U, bytes, length, 7U);
|
||
command_raw_reply_at(1U, bytes, length, 10U);
|
||
} else {
|
||
command_flush();
|
||
CHECK(command_status.rejected == 1U && command_action_calls == 0U && !command_status.busy);
|
||
CHECK(command_frame_count() == 1U);
|
||
command_raw_reply_at(0U, bytes, length, cause == 6U ? 0x47U : 0x49U);
|
||
}
|
||
command_empty();
|
||
command_close();
|
||
}
|
||
}
|
||
}
|
||
++command_checks;
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:非法限定词不能被决定期同OA重发规则吞掉,也不能终结原选择或撤销原事务。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:每个类型覆盖SELECT_WAIT、SELECTED及直接EXECUTE_WAIT;激活和撤销均遍历S/E=0、1。
|
||
* 后续原请求仍能正常执行一次,证明工作事件、原文、站点身份没有被坏请求覆盖。
|
||
*/
|
||
static void test_command_qualifier_preserves_transaction(void)
|
||
{
|
||
static const unsigned types[] = {45U, 46U, 47U, 48U, 49U, 50U, 58U, 59U, 60U, 61U, 62U, 63U};
|
||
size_t type_index;
|
||
unsigned phase, cause, variant;
|
||
for (type_index = 0U; type_index < sizeof(types) / sizeof(types[0]); ++type_index) {
|
||
unsigned type = types[type_index];
|
||
unsigned invalid = type <= 47U || (type >= 58U && type <= 60U) ? 4U : 1U;
|
||
for (phase = 0U; phase < 3U; ++phase) {
|
||
IEC104_CommandConfig_t config;
|
||
IEC104_CommandEvent_t event;
|
||
IEC104_CommandTransactionInfo_t info;
|
||
uint8_t original[32], invalid_bytes[32];
|
||
size_t length;
|
||
unsigned replies = 0U;
|
||
command_timed_config(&config, type, 0U);
|
||
if (phase != 2U) { command_config_mode(&config, IEC104_COMMAND_MODE_SELECT_EXECUTE); }
|
||
command_open(&config);
|
||
length = command_qualified_bytes(original, type, 6U, 0U, phase != 2U);
|
||
command_raw_send(original, length);
|
||
event = command_take(phase == 2U ? IEC104_COMMAND_EXECUTE : IEC104_COMMAND_SELECT);
|
||
if (phase == 1U) {
|
||
CHECK(IEC104_Command_Accept(command, &event, NULL, NULL) == IEC104_COMMAND_REPLY_OK);
|
||
command_flush();
|
||
++replies;
|
||
}
|
||
for (variant = 0U; variant < 4U; ++variant) {
|
||
cause = variant < 2U ? 6U : 8U;
|
||
CHECK(command_qualified_bytes(invalid_bytes, type, cause, invalid, (variant & 1U) != 0U) == length);
|
||
command_raw_send(invalid_bytes, length);
|
||
command_flush();
|
||
command_raw_reply_at(replies++, invalid_bytes, length, cause == 6U ? 0x47U : 0x49U);
|
||
CHECK(IEC104_Command_Get_Transaction(command, &event, &info) && info.active);
|
||
CHECK(info.phase == (phase == 0U ? IEC104_COMMAND_PHASE_SELECT_WAIT :
|
||
(phase == 1U ? IEC104_COMMAND_PHASE_SELECTED : IEC104_COMMAND_PHASE_EXECUTE_WAIT)));
|
||
CHECK(command_action_calls == 0U);
|
||
command_empty();
|
||
}
|
||
CHECK(command_status.rejected == 4U && command_status.dropped_requests == 0U);
|
||
if (phase == 0U) {
|
||
CHECK(IEC104_Command_Accept(command, &event, NULL, NULL) == IEC104_COMMAND_REPLY_OK);
|
||
command_flush();
|
||
}
|
||
if (phase != 2U) {
|
||
CHECK(command_qualified_bytes(original, type, 6U, 0U, false) == length);
|
||
command_raw_send(original, length);
|
||
event = command_take(IEC104_COMMAND_EXECUTE);
|
||
}
|
||
CHECK(event.request.qualifier == 0U);
|
||
CHECK(IEC104_Command_Accept(command, &event, command_action,
|
||
&command_action_calls) == IEC104_COMMAND_REPLY_OK);
|
||
(void)command_done(&event, IEC104_COMMAND_RESULT_SUCCEEDED);
|
||
CHECK(command_action_calls == 1U && command_action_request.qualifier == 0U);
|
||
command_empty();
|
||
command_close();
|
||
}
|
||
}
|
||
++command_checks;
|
||
}
|
||
|
||
/**
|
||
* 功能:在普通重入探针之前尝试设置/清除时间基准,核对只读查询仍有效且基准不变。
|
||
* 输入参数:context——业务回调的测试上下文;request——当前业务请求(只读)。
|
||
* 输出参数:无。
|
||
* 返回值:业务动作结果,保留应用成功、业务拒绝及未知对象等协议区别。
|
||
* 说明:该替身只检查回调保护;执行时效及回调返回后的后续请求由用例单独断言。
|
||
*/
|
||
static IEC104_CommandActionResult_t command_time_reentry_action(void *context,
|
||
const IEC104_CommandRequest_t *request)
|
||
{
|
||
IEC104_CommandStatus_t status;
|
||
CHECK(!IEC104_Command_Set_Time_Base(command, 0U, fake.now));
|
||
IEC104_Command_Clear_Time_Base(command);
|
||
CHECK(IEC104_Command_Get_Status(command, &status) && status.time_base_valid);
|
||
return command_reentry_action(context, request);
|
||
}
|
||
|
||
/* ============================================================================
|
||
* [COMMAND/TIMED] 带时标用例:完整流程、UTC换算、时间窗、基准与重入
|
||
* ============================================================================ */
|
||
/**
|
||
* 功能:验证以下场景与约束:七类时标命令分别验证完整规范长度和字段。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:选择/执行时标不同仍匹配。
|
||
* max=0不依赖基准;执行使用的值和时标不能被应用修改的事件副本替换。
|
||
*/
|
||
static void test_command_timed_flows(void)
|
||
{
|
||
size_t index;
|
||
for (index = 0U; index < sizeof(command_timed_cases) / sizeof(command_timed_cases[0]); ++index) {
|
||
IEC104_CommandConfig_t config;
|
||
IEC104_CommandEvent_t event, finished;
|
||
uint8_t selected[32], executed[32], time_bytes[7];
|
||
size_t length;
|
||
unsigned type = command_timed_cases[index].type;
|
||
unsigned preceding = type == 64U ? 0U : 1U;
|
||
command_timed_config(&config, type, 0U);
|
||
if (type != 64U) { command_config_mode(&config, IEC104_COMMAND_MODE_SELECT_EXECUTE); }
|
||
command_open(&config);
|
||
length = command_timed_bytes(selected, type, 6U, 0x51U, 1U, 6001U,
|
||
command_timed_cases[index].payload, command_timed_cases[index].payload_length, command_epoch_time);
|
||
CHECK(length == (type <= 60U ? 17U : (type <= 62U ? 19U : (type == 63U ? 21U : 20U))));
|
||
if (type != 64U) {
|
||
selected[9U + command_timed_cases[index].qualifier_offset] |= 0x80U;
|
||
command_raw_send(selected, length);
|
||
event = command_take(IEC104_COMMAND_SELECT);
|
||
command_check_value(&event.request, type);
|
||
CHECK(event.request.has_time && event.request.time_utc_ms == command_epoch_ms);
|
||
CHECK(event.request.is_select && !event.request.selected);
|
||
CHECK(IEC104_Command_Accept(command, &event, NULL, NULL) == IEC104_COMMAND_REPLY_OK);
|
||
command_flush();
|
||
command_raw_reply_at(0U, selected, length, 7U);
|
||
}
|
||
memcpy(time_bytes, command_epoch_time, sizeof(time_bytes));
|
||
time_bytes[0] = 0xd2U; time_bytes[1] = 4U;
|
||
CHECK(command_timed_bytes(executed, type, 6U, 0x51U, 1U, 6001U,
|
||
command_timed_cases[index].payload, command_timed_cases[index].payload_length, time_bytes) == length);
|
||
command_raw_send(executed, length);
|
||
event = command_take(IEC104_COMMAND_EXECUTE);
|
||
command_check_value(&event.request, type);
|
||
CHECK(event.request.has_time && event.request.time_utc_ms == command_epoch_ms + 1234U);
|
||
CHECK(event.request.time.time.second == 1U && event.request.time.time.ms == 234U);
|
||
CHECK(event.request.selected == (type != 64U) && !event.request.is_select);
|
||
event.request.value.bitstring = 0U;
|
||
event.request.state = 0U;
|
||
event.request.time_utc_ms = 0U;
|
||
memset(&event.request.time, 0, sizeof(event.request.time));
|
||
CHECK(IEC104_Command_Accept(command, &event, command_action, &command_action_calls) == IEC104_COMMAND_REPLY_OK);
|
||
command_check_value(&command_action_request, type);
|
||
CHECK(command_action_calls == 1U && command_action_request.time_utc_ms == command_epoch_ms + 1234U);
|
||
finished = command_done(&event, IEC104_COMMAND_RESULT_SUCCEEDED);
|
||
command_check_value(&finished.request, type);
|
||
CHECK(finished.request.has_time && finished.request.time_utc_ms == command_epoch_ms + 1234U);
|
||
command_raw_reply_at(preceding, executed, length, 7U);
|
||
command_raw_reply_at(preceding + 1U, executed, length, 10U);
|
||
CHECK(command_frame_count() == preceding + 2U);
|
||
command_close();
|
||
}
|
||
/* 相同语义值不能跨类型执行:49->48、45->58;最长命令还单独验证OA不匹配。 */
|
||
for (index = 0U; index < 3U; ++index) {
|
||
IEC104_CommandConfig_t config;
|
||
IEC104_CommandEvent_t event, finished;
|
||
uint8_t selected[32], executed[32];
|
||
static const uint8_t scaled[] = {0U, 0x80U, 0U};
|
||
static const uint8_t single[] = {1U};
|
||
static const uint8_t real_value[] = {0U, 0U, 0xa0U, 0xbfU, 0U};
|
||
unsigned select_type = index == 0U ? 49U : (index == 1U ? 45U : 63U);
|
||
unsigned execute_type = index == 0U ? 48U : (index == 1U ? 58U : 63U);
|
||
size_t selected_length, executed_length;
|
||
command_timed_config(&config, select_type, 0U);
|
||
config.type_mask |= IEC104_COMMAND_TYPE_BIT(execute_type);
|
||
command_config_mode(&config, IEC104_COMMAND_MODE_SELECT_EXECUTE);
|
||
command_open(&config);
|
||
if (index == 0U) {
|
||
selected_length = command_payload_bytes(selected, select_type, 6U, 0x51U, 1U, 6001U,
|
||
scaled, sizeof(scaled));
|
||
selected[11] |= 0x80U;
|
||
executed_length = command_payload_bytes(executed, execute_type, 6U, 0x51U, 1U, 6001U,
|
||
scaled, sizeof(scaled));
|
||
} else if (index == 1U) {
|
||
selected_length = command_payload_bytes(selected, select_type, 6U, 0x51U, 1U, 6001U,
|
||
single, sizeof(single));
|
||
selected[9] |= 0x80U;
|
||
executed_length = command_timed_bytes(executed, execute_type, 6U, 0x51U, 1U, 6001U,
|
||
single, sizeof(single), command_epoch_time);
|
||
} else {
|
||
selected_length = command_timed_bytes(selected, select_type, 6U, 0x51U, 1U, 6001U,
|
||
real_value, sizeof(real_value), command_epoch_time);
|
||
selected[13] |= 0x80U;
|
||
executed_length = command_timed_bytes(executed, execute_type, 6U, 0x52U, 1U, 6001U,
|
||
real_value, sizeof(real_value), command_epoch_time);
|
||
}
|
||
command_raw_send(selected, selected_length);
|
||
event = command_take(IEC104_COMMAND_SELECT);
|
||
CHECK(IEC104_Command_Accept(command, &event, NULL, NULL) == IEC104_COMMAND_REPLY_OK);
|
||
command_flush();
|
||
command_raw_send(executed, executed_length);
|
||
command_flush();
|
||
finished = command_take(IEC104_COMMAND_FINISHED);
|
||
CHECK(finished.reason == IEC104_COMMAND_FINISH_MISMATCH);
|
||
CHECK(finished.request.type_id == select_type && finished.request.originator_address == 0x51U);
|
||
CHECK(command_action_calls == 0U && command_frame_count() == 2U);
|
||
command_raw_reply_at(0U, selected, selected_length, 7U);
|
||
command_raw_reply_at(1U, executed, executed_length, 0x47U);
|
||
command_empty();
|
||
command_close();
|
||
}
|
||
++command_checks;
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:原始时标带SU时只扣一次夏令时,并使用显式主站标准时区。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:保留毫秒和原始SU。
|
||
*/
|
||
static void test_command_time_conversion(void)
|
||
{
|
||
static const struct { int offset; uint8_t bytes[7]; unsigned summer; } cases[] = {
|
||
{0, {0xd2U, 4U, 0U, 0U, 1U, 1U, 26U}, 0U},
|
||
{480, {0xd2U, 4U, 0U, 8U, 1U, 1U, 26U}, 0U},
|
||
{480, {0xd2U, 4U, 0U, 0x89U, 1U, 1U, 26U}, 1U},
|
||
{0, {0xd2U, 4U, 0U, 0x81U, 1U, 1U, 26U}, 1U},
|
||
{-330, {0xd2U, 4U, 30U, 18U, 31U, 12U, 25U}, 0U}
|
||
};
|
||
static const uint8_t value[] = {1U};
|
||
size_t index;
|
||
for (index = 0U; index < sizeof(cases) / sizeof(cases[0]); ++index) {
|
||
IEC104_CommandConfig_t config;
|
||
IEC104_CommandEvent_t event;
|
||
uint8_t bytes[32];
|
||
size_t length;
|
||
command_timed_config(&config, 58U, 0U);
|
||
config.master_utc_offset_minutes = (int16_t)cases[index].offset;
|
||
command_open(&config);
|
||
length = command_timed_bytes(bytes, 58U, 6U, 0x51U, 1U, 6001U, value, sizeof(value), cases[index].bytes);
|
||
command_raw_send(bytes, length);
|
||
event = command_take(IEC104_COMMAND_EXECUTE);
|
||
CHECK(event.request.has_time && event.request.time_utc_ms == command_epoch_ms + 1234U);
|
||
CHECK(event.request.time.time.ms == 234U && event.request.time.is_summer_time == cases[index].summer);
|
||
CHECK(IEC104_Command_Accept(command, &event, command_action, &command_action_calls) == IEC104_COMMAND_REPLY_OK);
|
||
(void)command_done(&event, IEC104_COMMAND_RESULT_SUCCEEDED);
|
||
command_raw_reply_at(0U, bytes, length, 7U);
|
||
command_raw_reply_at(1U, bytes, length, 10U);
|
||
command_close();
|
||
}
|
||
++command_checks;
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:接收端忽略辅助星期与GEN,不放宽真实日历、IV和10s动作时效。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:四种输入分别为无星期、错误星期、GEN、错误星期加GEN;肯定/否定确认均回显原文。
|
||
* TEST仅模拟CON/TERM;真实动作在Accept前再次到达10s边界时仍须拒绝。
|
||
*/
|
||
static void test_command_timed_auxiliary_fields(void)
|
||
{
|
||
size_t index;
|
||
unsigned variant, mode;
|
||
for (index = 0U; index < sizeof(command_timed_cases) / sizeof(command_timed_cases[0]); ++index) {
|
||
for (variant = 0U; variant < 4U; ++variant) {
|
||
for (mode = 0U; mode < 6U; ++mode) {
|
||
IEC104_CommandConfig_t config;
|
||
uint8_t bytes[32], time_bytes[7];
|
||
size_t length;
|
||
command_timed_config(&config, command_timed_cases[index].type, 10000U);
|
||
CHECK(config.negative_on_expired && config.decision_timeout_ms == 15000U);
|
||
command_open(&config);
|
||
CHECK(IEC104_Command_Set_Time_Base(command,
|
||
command_epoch_ms + (mode == 2U ? 10000U : 0U), fake.now));
|
||
memcpy(time_bytes, command_epoch_time, sizeof(time_bytes));
|
||
if ((variant & 1U) != 0U) { time_bytes[4] |= 0x20U; } /* 周四故意填写周一。 */
|
||
if ((variant & 2U) != 0U) { time_bytes[2] |= 0x40U; } /* RES1/GEN不是保留位。 */
|
||
if (mode == 4U) { time_bytes[2] |= 0x80U; }
|
||
if (mode == 5U) {
|
||
time_bytes[4] = (uint8_t)((time_bytes[4] & 0xe0U) | 30U);
|
||
time_bytes[5] = 2U; /* 2026-02-30:不能被辅助字段兼容掩盖。 */
|
||
}
|
||
length = command_timed_bytes(bytes, command_timed_cases[index].type,
|
||
mode == 1U ? 0x86U : 6U, 0x61U, 1U, 6001U,
|
||
command_timed_cases[index].payload, command_timed_cases[index].payload_length, time_bytes);
|
||
command_raw_send(bytes, length);
|
||
if (mode == 0U || mode == 3U) {
|
||
IEC104_CommandEvent_t event = command_take(IEC104_COMMAND_EXECUTE);
|
||
CHECK(event.request.time_utc_ms == command_epoch_ms && event.request.time.time.weekday == 4U);
|
||
CHECK(event.request.time.has_weekday == ((variant & 1U) != 0U));
|
||
if (mode == 3U) {
|
||
fake.now += 10000U;
|
||
CHECK(IEC104_Command_Accept(command, &event, command_action,
|
||
&command_action_calls) == IEC104_COMMAND_REPLY_STALE);
|
||
CHECK(command_take(IEC104_COMMAND_FINISHED).reason == IEC104_COMMAND_FINISH_TIME_EXPIRED);
|
||
} else {
|
||
CHECK(IEC104_Command_Accept(command, &event, command_action,
|
||
&command_action_calls) == IEC104_COMMAND_REPLY_OK);
|
||
(void)command_done(&event, IEC104_COMMAND_RESULT_SUCCEEDED);
|
||
}
|
||
}
|
||
command_flush(); command_empty();
|
||
CHECK(command_action_calls == (mode == 0U ? 1U : 0U));
|
||
CHECK(command_frame_count() == (mode <= 1U ? 2U : 1U));
|
||
command_raw_reply_at(0U, bytes, length, mode == 0U ? 7U : mode == 1U ? 0x87U : 0x71U);
|
||
if (mode <= 1U) { command_raw_reply_at(1U, bytes, length, mode == 0U ? 10U : 0x8aU); }
|
||
CHECK(command_status.time_expired == (mode == 2U ? 1U : 0U));
|
||
CHECK(command_status.action_time_expired == (mode == 3U ? 1U : 0U));
|
||
CHECK(command_status.time_rejected == (mode >= 4U ? 1U : 0U));
|
||
CHECK(!command_status.busy && command_status.pending_events == 0U);
|
||
command_close();
|
||
}
|
||
}
|
||
}
|
||
++command_checks;
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:关闭新鲜度检查仍拒绝IV、真正保留位、非法日历和UTC越界,且保留非法原文用于否定回显。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。
|
||
*/
|
||
static void test_command_timed_invalid_values(void)
|
||
{
|
||
size_t index;
|
||
unsigned variant;
|
||
for (index = 0U; index < sizeof(command_timed_cases) / sizeof(command_timed_cases[0]); ++index) {
|
||
for (variant = 0U; variant < 10U; ++variant) {
|
||
IEC104_CommandConfig_t config;
|
||
uint8_t bytes[32], time_bytes[7];
|
||
size_t length;
|
||
command_timed_config(&config, command_timed_cases[index].type, 0U);
|
||
memcpy(time_bytes, command_epoch_time, sizeof(time_bytes));
|
||
switch (variant) {
|
||
case 0U: time_bytes[2] = 0x80U; break;
|
||
case 1U: time_bytes[3] = 0x40U; break;
|
||
case 2U: time_bytes[3] = 0x20U; break;
|
||
case 3U: time_bytes[5] = 0x11U; break;
|
||
case 4U: time_bytes[6] |= 0x80U; break;
|
||
case 5U: time_bytes[0] = 0x60U; time_bytes[1] = 0xeaU; break;
|
||
case 6U: time_bytes[4] = 30U; time_bytes[5] = 2U; break;
|
||
case 7U: time_bytes[5] = 0x81U; break;
|
||
case 8U: time_bytes[6] = 100U; break;
|
||
default:
|
||
time_bytes[0] = 0x5fU; time_bytes[1] = 0xeaU;
|
||
time_bytes[2] = 59U; time_bytes[3] = 23U;
|
||
time_bytes[4] = 31U; time_bytes[5] = 12U; time_bytes[6] = 99U;
|
||
config.master_utc_offset_minutes = -1;
|
||
break;
|
||
}
|
||
command_open(&config);
|
||
length = command_timed_bytes(bytes, command_timed_cases[index].type, 6U, 0x61U, 1U, 6001U,
|
||
command_timed_cases[index].payload, command_timed_cases[index].payload_length, time_bytes);
|
||
command_raw_send(bytes, length);
|
||
command_flush();
|
||
CHECK(command_frame_count() == 1U && command_action_calls == 0U);
|
||
command_raw_reply_at(0U, bytes, length, 0x71U);
|
||
CHECK(command_status.rejected == 1U && !command_status.busy);
|
||
CHECK(command_status.time_rejected == 1U);
|
||
command_empty();
|
||
command_close();
|
||
}
|
||
}
|
||
/* 时标类型也必须复用SCO/DCS/RCS及浮点值校验,而非只验证CP56。 */
|
||
for (variant = 0U; variant < 6U; ++variant) {
|
||
IEC104_CommandConfig_t config;
|
||
uint8_t bytes[32], payload[5] = {0U, 0U, 0x80U, 0x7fU, 0U};
|
||
unsigned type = variant < 3U ? 58U + variant : 63U;
|
||
size_t payload_length = type == 63U ? 5U : 1U;
|
||
size_t length;
|
||
if (variant == 0U) { payload[0] = 2U; }
|
||
else if (variant == 1U) { payload[0] = 0U; }
|
||
else if (variant == 2U) { payload[0] = 3U; }
|
||
else if (variant == 4U) { payload[3] = 0xffU; }
|
||
else if (variant == 5U) { payload[2] = 0xc0U; }
|
||
command_timed_config(&config, type, 0U);
|
||
command_open(&config);
|
||
length = command_timed_bytes(bytes, type, 6U, 0x61U, 1U, 6001U, payload, payload_length, command_epoch_time);
|
||
command_raw_send(bytes, length);
|
||
command_flush();
|
||
command_raw_reply_at(0U, bytes, length, 0x47U);
|
||
CHECK(command_frame_count() == 1U && command_action_calls == 0U && !command_status.busy);
|
||
command_empty();
|
||
command_close();
|
||
}
|
||
++command_checks;
|
||
}
|
||
|
||
/**
|
||
* 功能:验证七类时标命令的坏CP56返回49,混合命令值、限定词或报文结构错误仍优先返回7/9。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:交叉真实/TEST和激活/撤销,保留原始时标回显;时间拒绝只计一次,较早的命令错误不计入时间拒绝。
|
||
*/
|
||
static void test_command_timed_error_precedence(void)
|
||
{
|
||
size_t index;
|
||
unsigned test, deactivation, variant;
|
||
for (index = 0U; index < sizeof(command_timed_cases) / sizeof(command_timed_cases[0]); ++index) {
|
||
unsigned type = command_timed_cases[index].type;
|
||
for (test = 0U; test < 2U; ++test) {
|
||
for (deactivation = 0U; deactivation < 2U; ++deactivation) {
|
||
for (variant = 0U; variant < 7U; ++variant) {
|
||
IEC104_CommandConfig_t config;
|
||
uint8_t bytes[32], time_bytes[7], payload[5];
|
||
unsigned flag = test ? 0x80U : 0U;
|
||
unsigned cause = deactivation ? 8U : 6U;
|
||
unsigned expected = variant < 2U ? 0x71U : (deactivation ? 0x49U : 0x47U);
|
||
size_t length, received;
|
||
if (variant == 2U && (type == 61U || type == 62U || type == 64U)) { continue; }
|
||
if (variant == 3U && type == 64U) { continue; }
|
||
command_timed_config(&config, type, 1000U);
|
||
command_open(&config);
|
||
memcpy(payload, command_timed_cases[index].payload, sizeof(payload));
|
||
memcpy(time_bytes, command_epoch_time, sizeof(time_bytes));
|
||
if (variant == 0U) { time_bytes[3] |= 0x20U; }
|
||
else { time_bytes[4] = 30U; time_bytes[5] = 2U; }
|
||
if (variant == 2U) {
|
||
if (type == 58U) { payload[0] |= 0x02U; }
|
||
else if (type == 59U || type == 60U) { payload[0] &= 0xfcU; }
|
||
else { payload[0] = payload[1] = 0U; payload[2] = 0xc0U; payload[3] = 0x7fU; }
|
||
} else if (variant == 3U) {
|
||
unsigned offset = command_timed_cases[index].qualifier_offset;
|
||
payload[offset] = type <= 60U ? (uint8_t)((payload[offset] & 0x03U) | 0x10U) : 1U;
|
||
}
|
||
length = command_timed_bytes(bytes, type, cause | flag, 0x6bU, 1U, 6001U,
|
||
payload, command_timed_cases[index].payload_length, time_bytes);
|
||
received = length;
|
||
if (variant == 4U) { bytes[2] |= 0x40U; }
|
||
else if (variant == 5U) { bytes[1] |= 0x80U; }
|
||
else if (variant == 6U) { bytes[received++] = 0x5aU; }
|
||
command_raw_send(bytes, received); command_flush(); command_empty();
|
||
command_raw_reply_at(0U, bytes, length, expected | flag);
|
||
CHECK(command_frame_count() == 1U && command_action_calls == 0U && !command_status.busy);
|
||
CHECK(command_status.rejected == 1U && command_status.time_rejected == (variant < 2U ? 1U : 0U));
|
||
CHECK(command_status.time_expired == 0U && command_status.app_rejected == 0U);
|
||
command_close();
|
||
}
|
||
}
|
||
}
|
||
}
|
||
++command_checks;
|
||
}
|
||
|
||
/**
|
||
* 功能:验证普通撤销可忽略IV、时效及基准,TEST撤销须校验;坏CP56编码对两者均回49且保留选择。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:每项先建立选择,拒绝后用新鲜时标成功撤销,确认时间错误不会误清许可或启动动作。
|
||
*/
|
||
static void test_command_deactivation_time_rules(void)
|
||
{
|
||
unsigned test, mode;
|
||
for (test = 0U; test < 2U; ++test) {
|
||
for (mode = 0U; mode < 5U; ++mode) {
|
||
IEC104_CommandConfig_t config;
|
||
uint8_t bytes[32], payload = 0x81U;
|
||
unsigned flag = test ? 0x80U : 0U, replies = 0U;
|
||
bool rejected = test != 0U || mode == 4U;
|
||
size_t length;
|
||
command_timed_config(&config, 58U, 1000U);
|
||
command_config_mode(&config, IEC104_COMMAND_MODE_SELECT_EXECUTE);
|
||
config.negative_on_expired = false;
|
||
command_open(&config);
|
||
CHECK(IEC104_Command_Set_Time_Base(command, command_epoch_ms, fake.now));
|
||
length = command_timed_bytes(bytes, 58U, 6U | flag, 0x6cU, 1U, 6001U,
|
||
&payload, 1U, command_epoch_time);
|
||
command_raw_send(bytes, length);
|
||
if (!test) {
|
||
IEC104_CommandEvent_t event = command_take(IEC104_COMMAND_SELECT);
|
||
CHECK(IEC104_Command_Accept(command, &event, NULL, NULL) == IEC104_COMMAND_REPLY_OK);
|
||
}
|
||
command_flush(); command_empty();
|
||
command_raw_reply_at(replies++, bytes, length, 7U | flag);
|
||
bytes[2] = (uint8_t)(8U | flag); bytes[9] = 1U;
|
||
if (mode == 0U) { bytes[length - 5U] |= 0x80U; }
|
||
else if (mode == 1U) { fake.now += 1000U; }
|
||
else if (mode == 2U) { IEC104_Command_Clear_Time_Base(command); }
|
||
else if (mode == 3U) { CHECK(IEC104_Command_Set_Time_Base(command, command_epoch_ms - 1000U, fake.now)); }
|
||
else { bytes[length - 4U] |= 0x20U; }
|
||
command_raw_send(bytes, length); command_flush();
|
||
command_raw_reply_at(replies++, bytes, length, (rejected ? 0x71U : 9U) | flag);
|
||
/* 真实撤销成功仍等待应用读取FINISHED,因此槽此时也必须保持占用。 */
|
||
CHECK(command_status.busy && command_action_calls == 0U);
|
||
CHECK(command_status.pending_events == (rejected ? 0U : 1U));
|
||
CHECK(command_status.rejected == (rejected ? 1U : 0U));
|
||
CHECK(command_status.time_expired == (test && mode == 1U ? 1U : 0U));
|
||
CHECK(command_status.time_rejected == (rejected && mode != 1U ? 1U : 0U));
|
||
if (rejected) {
|
||
command_empty();
|
||
memcpy(bytes + length - 7U, command_epoch_time, sizeof(command_epoch_time));
|
||
CHECK(IEC104_Command_Set_Time_Base(command, command_epoch_ms, fake.now));
|
||
command_raw_send(bytes, length); command_flush();
|
||
command_raw_reply_at(replies++, bytes, length, 9U | flag);
|
||
}
|
||
if (!test) { CHECK(command_take(IEC104_COMMAND_FINISHED).reason == IEC104_COMMAND_FINISH_DEACTIVATED); }
|
||
command_empty(); command_process();
|
||
CHECK(command_frame_count() == replies && !command_status.busy && command_action_calls == 0U);
|
||
command_close();
|
||
}
|
||
}
|
||
++command_checks;
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:过去和未来采用同一严格窗口:差值等于上限即不接受。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:过去显式覆盖否定/静默,未来总是否定。
|
||
*/
|
||
static void test_command_time_boundaries(void)
|
||
{
|
||
unsigned future, negative, boundary;
|
||
static const uint8_t value[] = {1U};
|
||
for (future = 0U; future < 2U; ++future) {
|
||
for (negative = 0U; negative < 2U; ++negative) {
|
||
for (boundary = 0U; boundary < 3U; ++boundary) {
|
||
IEC104_CommandConfig_t config;
|
||
uint8_t bytes[32];
|
||
size_t length;
|
||
uint64_t difference = 999U + boundary;
|
||
command_timed_config(&config, 58U, 1000U);
|
||
config.negative_on_expired = negative != 0U;
|
||
command_open(&config);
|
||
CHECK(IEC104_Command_Set_Time_Base(command,
|
||
future ? command_epoch_ms - difference : command_epoch_ms + difference, fake.now));
|
||
length = command_timed_bytes(bytes, 58U, 6U, 0x51U, 1U, 6001U,
|
||
value, sizeof(value), command_epoch_time);
|
||
command_raw_send(bytes, length);
|
||
command_flush();
|
||
CHECK(command_status.time_base_valid && command_status.dropped_requests == 0U);
|
||
if (boundary == 0U) {
|
||
IEC104_CommandEvent_t event = command_take(IEC104_COMMAND_EXECUTE);
|
||
CHECK(event.request.time_utc_ms == command_epoch_ms);
|
||
CHECK(command_status.time_expired == 0U && command_status.time_rejected == 0U);
|
||
CHECK(command_status.rejected == 0U && command_frame_count() == 0U);
|
||
} else {
|
||
CHECK(command_status.time_expired == (future ? 0U : 1U));
|
||
CHECK(command_status.time_rejected == (future ? 1U : 0U));
|
||
CHECK(command_status.rejected == (future || negative ? 1U : 0U));
|
||
CHECK(command_frame_count() == (future || negative ? 1U : 0U));
|
||
if (future || negative) { command_raw_reply_at(0U, bytes, length, 0x71U); }
|
||
command_empty();
|
||
}
|
||
CHECK(command_action_calls == 0U);
|
||
command_close();
|
||
}
|
||
}
|
||
}
|
||
++command_checks;
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:不覆盖默认窗口、时区或回复策略:58–64收到时恰好过期,须各有且仅有一条否定。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:58–63分别覆盖选择和直接执行;64没有S/E,只有执行。过期请求不得建立事务、
|
||
* 产生业务事件或调用动作;重复Process和传输推进也不得再回复或留下零超时唤醒。
|
||
*/
|
||
static void test_command_default_received_expiry(void)
|
||
{
|
||
static const uint8_t local_time[7] = {0U, 0U, 0U, 8U, 1U, 1U, 26U};
|
||
size_t index;
|
||
unsigned selecting;
|
||
for (index = 0U; index < sizeof(command_timed_cases) / sizeof(command_timed_cases[0]); ++index) {
|
||
unsigned type = command_timed_cases[index].type;
|
||
for (selecting = 0U; selecting < (type == 64U ? 1U : 2U); ++selecting) {
|
||
IEC104_CommandConfig_t config;
|
||
uint8_t bytes[32];
|
||
size_t length;
|
||
command_config_default(&config);
|
||
CHECK(config.negative_on_expired && config.time_tag_max_delay_ms == 10000U);
|
||
CHECK(config.master_utc_offset_minutes == 480 && config.decision_timeout_ms == 15000U);
|
||
command_config_mode(&config, selecting ? IEC104_COMMAND_MODE_SELECT_EXECUTE :
|
||
IEC104_COMMAND_MODE_DIRECT);
|
||
command_open(&config);
|
||
CHECK(IEC104_Command_Set_Time_Base(command, command_epoch_ms + 10000U, fake.now));
|
||
length = command_timed_bytes(bytes, type, 6U, 0x51U, 1U, 6001U,
|
||
command_timed_cases[index].payload, command_timed_cases[index].payload_length, local_time);
|
||
if (selecting) { bytes[9U + command_timed_cases[index].qualifier_offset] |= 0x80U; }
|
||
command_raw_send(bytes, length);
|
||
command_flush();
|
||
command_empty();
|
||
command_process();
|
||
command_flush();
|
||
CHECK(command_frame_count() == 1U && command_action_calls == 0U);
|
||
command_raw_reply_at(0U, bytes, length, 0x71U);
|
||
CHECK(command_status.time_expired == 1U && command_status.time_rejected == 0U);
|
||
CHECK(command_status.rejected == 1U && command_status.negative_submitted == 1U);
|
||
CHECK(command_status.accepted == 0U && command_status.selected == 0U && command_status.executed == 0U);
|
||
CHECK(command_status.action_time_expired == 0U && command_status.decision_timeouts == 0U);
|
||
CHECK(!command_status.busy && !command_status.timer_active && !command_status.need_process);
|
||
CHECK(command_status.pending_events == 0U && command_status.pending_replies == 0U);
|
||
command_empty();
|
||
command_close();
|
||
}
|
||
}
|
||
++command_checks;
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:基准缺失、单调时钟倒退和推算UTC越界都明确否定。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:不能通过无符号回绕变成新鲜请求。
|
||
*/
|
||
static void test_command_time_base_errors(void)
|
||
{
|
||
unsigned variant;
|
||
static const uint8_t value[] = {1U};
|
||
const uint64_t maximum = (uint64_t)IEC60870_TIME_MAX_SECONDS * 1000U + 999U;
|
||
for (variant = 0U; variant < 4U; ++variant) {
|
||
IEC104_CommandConfig_t config;
|
||
uint8_t bytes[32];
|
||
size_t length;
|
||
command_timed_config(&config, 58U, 1000U);
|
||
command_open(&config);
|
||
if (variant == 1U) {
|
||
CHECK(IEC104_Command_Set_Time_Base(command, command_epoch_ms, fake.now));
|
||
} else if (variant == 2U) {
|
||
CHECK(IEC104_Command_Set_Time_Base(command, maximum, fake.now));
|
||
++fake.now;
|
||
} else if (variant == 3U) {
|
||
CHECK(IEC104_Command_Set_Time_Base(command, command_epoch_ms, fake.now));
|
||
IEC104_Command_Clear_Time_Base(command);
|
||
}
|
||
length = command_timed_bytes(bytes, 58U, 6U, 0x51U, 1U, 6001U,
|
||
value, sizeof(value), command_epoch_time);
|
||
if (variant == 1U) {
|
||
/* 在网络已收帧、业务尚未消费通知之间注入回退,避免传输层先处理同一个时钟故障。 */
|
||
command_queue(bytes, length);
|
||
CHECK(IEC104_Slave_Poll(command_slave, 0U, NULL) == IEC104_TCP_OK);
|
||
--fake.now;
|
||
command_drain_transport();
|
||
++fake.now;
|
||
} else { command_raw_send(bytes, length); }
|
||
command_flush();
|
||
if (variant != 1U) { command_raw_reply_at(0U, bytes, length, 0x71U); }
|
||
CHECK(command_status.time_rejected == 1U && command_status.time_expired == 0U);
|
||
CHECK(command_status.rejected == 1U && command_status.dropped_requests == 0U);
|
||
CHECK(command_status.clock_errors == (variant == 1U ? 1U : 0U));
|
||
CHECK(command_status.time_base_valid == (variant == 1U || variant == 2U));
|
||
/* 回退同样会被发送路径的Net期限检查发现并收尾,不能要求故障连接仍成功写出否定。 */
|
||
CHECK(command_action_calls == 0U && command_frame_count() == (variant == 1U ? 0U : 1U));
|
||
command_empty();
|
||
command_close();
|
||
}
|
||
++command_checks;
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:Invalid Set preserves the base。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:accepted timestamps stay immutable while
|
||
* Accept checks their freshness against the current base.
|
||
*/
|
||
static void test_command_time_base_api(void)
|
||
{
|
||
IEC104_CommandConfig_t config;
|
||
IEC104_CommandEvent_t event, finished;
|
||
uint8_t bytes[32];
|
||
size_t length;
|
||
static const uint8_t value[] = {1U};
|
||
const uint64_t maximum = (uint64_t)IEC60870_TIME_MAX_SECONDS * 1000U + 999U;
|
||
command_timed_config(&config, 58U, 1000U);
|
||
command_open(&config);
|
||
CHECK(!IEC104_Command_Set_Time_Base(NULL, command_epoch_ms, fake.now));
|
||
IEC104_Command_Clear_Time_Base(NULL);
|
||
CHECK(IEC104_Command_Set_Time_Base(command, 0U, fake.now));
|
||
CHECK(IEC104_Command_Set_Time_Base(command, maximum, fake.now));
|
||
CHECK(IEC104_Command_Set_Time_Base(command, command_epoch_ms - 100U, fake.now - 100U));
|
||
CHECK(!IEC104_Command_Set_Time_Base(command, maximum + 1U, fake.now));
|
||
CHECK(!IEC104_Command_Set_Time_Base(command, 0U, fake.now + 1U));
|
||
CHECK(!IEC104_Command_Set_Time_Base(command, UINT64_MAX, fake.now));
|
||
CHECK(!IEC104_Command_Set_Time_Base(command, 0U, UINT64_MAX));
|
||
length = command_timed_bytes(bytes, 58U, 6U, 0x51U, 1U, 6001U, value, sizeof(value), command_epoch_time);
|
||
command_raw_send(bytes, length);
|
||
event = command_take(IEC104_COMMAND_EXECUTE);
|
||
CHECK(event.request.time_utc_ms == command_epoch_ms);
|
||
IEC104_Command_Clear_Time_Base(command);
|
||
CHECK(IEC104_Command_Get_Status(command, &command_status) && !command_status.time_base_valid);
|
||
CHECK(IEC104_Command_Set_Time_Base(command, 0U, fake.now));
|
||
CHECK(IEC104_Command_Accept(command, &event, command_action, &command_action_calls) == IEC104_COMMAND_REPLY_STALE);
|
||
CHECK(command_action_calls == 0U);
|
||
command_flush();
|
||
finished = command_take(IEC104_COMMAND_FINISHED);
|
||
CHECK(finished.reason == IEC104_COMMAND_FINISH_TIME_REJECTED);
|
||
CHECK(finished.request.time_utc_ms == command_epoch_ms);
|
||
CHECK(command_status.time_rejected == 0U && command_status.time_expired == 0U);
|
||
CHECK(command_status.action_time_rejected == 1U);
|
||
command_raw_reply_at(0U, bytes, length, 0x71U);
|
||
CHECK(command_frame_count() == 1U);
|
||
command_close();
|
||
++command_checks;
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:STOP和断线只结束连接事务,可信时间基准继续有效。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:停用及离线时仍可显式更新。
|
||
*/
|
||
static void test_command_time_base_lifecycle(void)
|
||
{
|
||
IEC104_CommandConfig_t config;
|
||
IEC104_CommandEvent_t event;
|
||
uint8_t bytes[32];
|
||
size_t length;
|
||
static const uint8_t value[] = {1U};
|
||
command_timed_config(&config, 58U, 1000U);
|
||
command_open(&config);
|
||
CHECK(IEC104_Command_Set_Time_Base(command, command_epoch_ms, fake.now));
|
||
push(stop_act, sizeof(stop_act));
|
||
command_flush();
|
||
CHECK(!command_status.active && command_status.time_base_valid);
|
||
CHECK(IEC104_Command_Set_Time_Base(command, command_epoch_ms, fake.now));
|
||
push(start_act, sizeof(start_act));
|
||
command_flush();
|
||
CHECK(command_status.active && command_status.time_base_valid);
|
||
fake.recv_eof = 1U;
|
||
command_flush();
|
||
CHECK(!command_status.active && command_status.time_base_valid);
|
||
CHECK(IEC104_Command_Set_Time_Base(command, command_epoch_ms, fake.now));
|
||
fake.recv_eof = 0U;
|
||
command_connect();
|
||
length = command_timed_bytes(bytes, 58U, 6U, 0x51U, 1U, 6001U, value, sizeof(value), command_epoch_time);
|
||
command_raw_send(bytes, length);
|
||
event = command_take(IEC104_COMMAND_EXECUTE);
|
||
CHECK(event.request.time_utc_ms == command_epoch_ms);
|
||
CHECK(IEC104_Command_Accept(command, &event, command_action, &command_action_calls) == IEC104_COMMAND_REPLY_OK);
|
||
(void)command_done(&event, IEC104_COMMAND_RESULT_SUCCEEDED);
|
||
CHECK(command_status.time_base_valid);
|
||
IEC104_Command_Clear_Time_Base(command);
|
||
CHECK(IEC104_Command_Get_Status(command, &command_status) && !command_status.time_base_valid);
|
||
command_close();
|
||
++command_checks;
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:公共类型支持、时区配置边界和无S/E选择限制均在Create时校验。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。
|
||
*/
|
||
static void test_command_time_configuration(void)
|
||
{
|
||
static const IEC104_CommandPoint_t invalid = {1U, 6001U,
|
||
IEC104_COMMAND_TYPE_BIT(64U), IEC104_COMMAND_MODE_SELECT_EXECUTE};
|
||
IEC104_CommandConfig_t config;
|
||
unsigned type;
|
||
command_open(NULL);
|
||
CHECK(IEC104_Command_Destroy(command));
|
||
for (type = 58U; type <= 64U; ++type) {
|
||
command_timed_config(&config, type, 1000U);
|
||
config.master_utc_offset_minutes = type % 2U == 0U ? 1439 : -1439;
|
||
command = IEC104_Command_Create(command_slave, &config);
|
||
CHECK(command != NULL && IEC104_Command_Destroy(command));
|
||
}
|
||
config.points = &invalid;
|
||
config.point_count = 1U;
|
||
CHECK(IEC104_Command_Create(command_slave, &config) == NULL);
|
||
command_config_mode(&config, IEC104_COMMAND_MODE_DIRECT);
|
||
config.master_utc_offset_minutes = 1440;
|
||
CHECK(IEC104_Command_Create(command_slave, &config) == NULL);
|
||
config.master_utc_offset_minutes = -1440;
|
||
CHECK(IEC104_Command_Create(command_slave, &config) == NULL);
|
||
command_config_default(&config);
|
||
CHECK(config.type_mask == UINT16_C(0x3fff));
|
||
command = IEC104_Command_Create(command_slave, &config);
|
||
CHECK(command != NULL);
|
||
command_close();
|
||
++command_checks;
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:决定期执行重发先于时效。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:重复SELECT必须先校验时效,过期请求不能清除选择。
|
||
* CP56编码错误仍回49,其他点过期先于busy,真实撤销不要求新鲜时标或基准。
|
||
* 本组显式选静默策略,利用没有新增回复区分过期丢弃与普通忙拒绝。
|
||
*/
|
||
static void test_command_time_ordering(void)
|
||
{
|
||
unsigned selecting;
|
||
for (selecting = 0U; selecting < 2U; ++selecting) {
|
||
IEC104_CommandConfig_t config;
|
||
IEC104_CommandEvent_t event, finished;
|
||
uint8_t bytes[32], changed[32], payload[1];
|
||
size_t length;
|
||
command_timed_config(&config, 58U, 1000U);
|
||
config.negative_on_expired = false;
|
||
if (selecting) { command_config_mode(&config, IEC104_COMMAND_MODE_SELECT_EXECUTE); }
|
||
command_open(&config);
|
||
CHECK(IEC104_Command_Set_Time_Base(command, command_epoch_ms, fake.now));
|
||
payload[0] = selecting ? 0x81U : 1U;
|
||
length = command_timed_bytes(bytes, 58U, 6U, 0x51U, 1U, 6001U,
|
||
payload, sizeof(payload), command_epoch_time);
|
||
command_raw_send(bytes, length);
|
||
event = command_take(selecting ? IEC104_COMMAND_SELECT : IEC104_COMMAND_EXECUTE);
|
||
CHECK(IEC104_Command_Set_Time_Base(command, command_epoch_ms + 1000U, fake.now));
|
||
memcpy(changed, bytes, length);
|
||
command_raw_send(changed, length);
|
||
command_flush();
|
||
CHECK(command_status.dropped_requests == (selecting ? 0U : 1U) && command_status.time_expired == selecting);
|
||
CHECK(command_status.time_rejected == 0U && command_frame_count() == 0U);
|
||
changed[13] |= 0x20U; /* 小时RES2才是格式错误;分钟RES1/GEN接收时允许为1。 */
|
||
command_raw_send(changed, length);
|
||
command_flush();
|
||
command_raw_reply_at(0U, changed, length, 0x71U);
|
||
CHECK(command_status.rejected == 1U && command_status.dropped_requests == (selecting ? 0U : 1U));
|
||
memcpy(changed, bytes, length);
|
||
changed[6] += 1U;
|
||
command_raw_send(changed, length);
|
||
command_flush();
|
||
CHECK(command_status.time_expired == selecting + 1U && command_status.busy_rejected == 0U);
|
||
CHECK(command_status.rejected == 1U && command_frame_count() == 1U);
|
||
IEC104_Command_Clear_Time_Base(command);
|
||
memcpy(changed, bytes, length);
|
||
changed[2] = 8U;
|
||
changed[9] = 0U;
|
||
changed[length - 1U] = 25U;
|
||
command_raw_send(changed, length);
|
||
command_flush();
|
||
command_raw_reply_at(1U, changed, length, 9U);
|
||
finished = command_take(IEC104_COMMAND_FINISHED);
|
||
CHECK(finished.reason == IEC104_COMMAND_FINISH_DEACTIVATED);
|
||
CHECK(finished.request.receive_serial == event.request.receive_serial);
|
||
CHECK(finished.request.time_utc_ms == command_epoch_ms);
|
||
CHECK(command_status.time_rejected == 1U && command_action_calls == 0U);
|
||
command_empty();
|
||
command_close();
|
||
}
|
||
/* 过期执行不破坏原选择;分别验证恢复基准后执行,以及最终到选择保持期限终结。 */
|
||
for (selecting = 0U; selecting < 2U; ++selecting) {
|
||
IEC104_CommandConfig_t config;
|
||
IEC104_CommandEvent_t event;
|
||
IEC104_CommandTransactionInfo_t info;
|
||
uint8_t bytes[32];
|
||
static const uint8_t payload[] = {0x81U};
|
||
size_t length;
|
||
command_timed_config(&config, 58U, 1000U);
|
||
config.negative_on_expired = false;
|
||
command_config_mode(&config, IEC104_COMMAND_MODE_SELECT_EXECUTE);
|
||
command_open(&config);
|
||
CHECK(IEC104_Command_Set_Time_Base(command, command_epoch_ms, fake.now));
|
||
length = command_timed_bytes(bytes, 58U, 6U, 0x51U, 1U, 6001U,
|
||
payload, sizeof(payload), command_epoch_time);
|
||
command_raw_send(bytes, length);
|
||
event = command_take(IEC104_COMMAND_SELECT);
|
||
CHECK(IEC104_Command_Accept(command, &event, NULL, NULL) == IEC104_COMMAND_REPLY_OK);
|
||
command_flush();
|
||
CHECK(IEC104_Command_Set_Time_Base(command, command_epoch_ms + 1000U, fake.now));
|
||
bytes[9] = 1U;
|
||
command_raw_send(bytes, length);
|
||
command_flush();
|
||
command_empty();
|
||
CHECK(IEC104_Command_Get_Transaction(command, &event, &info));
|
||
CHECK(info.active && info.phase == IEC104_COMMAND_PHASE_SELECTED);
|
||
CHECK(command_status.time_expired == 1U && command_frame_count() == 1U);
|
||
if (selecting == 0U) {
|
||
CHECK(IEC104_Command_Set_Time_Base(command, command_epoch_ms, fake.now));
|
||
command_raw_send(bytes, length);
|
||
event = command_take(IEC104_COMMAND_EXECUTE);
|
||
CHECK(IEC104_Command_Accept(command, &event, command_action, &command_action_calls) == IEC104_COMMAND_REPLY_OK);
|
||
(void)command_done(&event, IEC104_COMMAND_RESULT_SUCCEEDED);
|
||
CHECK(command_action_calls == 1U && command_status.time_expired == 1U);
|
||
} else {
|
||
fake.now += config.select_timeout_ms;
|
||
command_flush();
|
||
event = command_take(IEC104_COMMAND_FINISHED);
|
||
CHECK(event.reason == IEC104_COMMAND_FINISH_SELECT_TIMEOUT);
|
||
CHECK(command_status.select_timeouts == 1U && command_status.time_expired == 1U);
|
||
CHECK(command_action_calls == 0U && command_frame_count() == 1U);
|
||
command_empty();
|
||
}
|
||
command_close();
|
||
}
|
||
++command_checks;
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:时基修改同样受动作回调保护。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:回调返回后再收请求,证明旧基准没有被替换或清除。
|
||
*/
|
||
static void test_command_time_base_reentry(void)
|
||
{
|
||
IEC104_CommandConfig_t config;
|
||
IEC104_CommandEvent_t event;
|
||
uint8_t bytes[32];
|
||
static const uint8_t payload[] = {1U};
|
||
size_t length;
|
||
command_timed_config(&config, 58U, 1000U);
|
||
command_open(&config);
|
||
CHECK(IEC104_Command_Set_Time_Base(command, command_epoch_ms, fake.now));
|
||
length = command_timed_bytes(bytes, 58U, 6U, 0x51U, 1U, 6001U,
|
||
payload, sizeof(payload), command_epoch_time);
|
||
command_raw_send(bytes, length);
|
||
command_reentry_event = command_take(IEC104_COMMAND_EXECUTE);
|
||
CHECK(IEC104_Command_Accept(command, &command_reentry_event, command_time_reentry_action,
|
||
&command_action_calls) == IEC104_COMMAND_REPLY_OK);
|
||
(void)command_done(&command_reentry_event, IEC104_COMMAND_RESULT_SUCCEEDED);
|
||
command_raw_send(bytes, length);
|
||
event = command_take(IEC104_COMMAND_EXECUTE);
|
||
CHECK(event.request.time_utc_ms == command_epoch_ms);
|
||
CHECK(command_status.time_rejected == 0U && command_action_calls == 1U);
|
||
command_close();
|
||
++command_checks;
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:完整21字节请求、17字节事务回复及独立短回复在WAIT期间各自保留长度。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:独立槽先保存最长非法请求,再复用为短请求,不能截断时标或带出旧尾部。
|
||
*/
|
||
static void test_command_timed_reply_lengths(void)
|
||
{
|
||
IEC104_CommandConfig_t config;
|
||
IEC104_CommandEvent_t event, finished;
|
||
uint8_t selected[32], executed[32], rejected[32], short_reply[32];
|
||
static const uint8_t selected_payload[] = {0U, 0U, 0xa0U, 0xbfU, 0x80U};
|
||
static const uint8_t executed_payload[] = {1U};
|
||
static const uint8_t short_payload[] = {0x81U};
|
||
size_t selected_length, executed_length, short_length;
|
||
command_timed_config(&config, 63U, 0U);
|
||
config.type_mask |= IEC104_COMMAND_TYPE_BIT(45U) | IEC104_COMMAND_TYPE_BIT(58U);
|
||
command_config_mode(&config, IEC104_COMMAND_MODE_SELECT_EXECUTE);
|
||
command_open(&config);
|
||
selected_length = command_timed_bytes(selected, 63U, 6U, 0x51U, 1U, 6001U,
|
||
selected_payload, sizeof(selected_payload), command_epoch_time);
|
||
command_raw_send(selected, selected_length);
|
||
event = command_take(IEC104_COMMAND_SELECT);
|
||
CHECK(IEC104_Command_Accept(command, &event, NULL, NULL) == IEC104_COMMAND_REPLY_OK);
|
||
command_flush();
|
||
command_congest();
|
||
memcpy(rejected, selected, selected_length);
|
||
rejected[3] = 0x62U;
|
||
rejected[4] = 2U;
|
||
command_raw_send(rejected, selected_length);
|
||
executed_length = command_timed_bytes(executed, 58U, 6U, 0x51U, 1U, 6001U,
|
||
executed_payload, sizeof(executed_payload), command_epoch_time);
|
||
command_raw_send(executed, executed_length);
|
||
command_process();
|
||
CHECK(command_status.pending_replies == 2U);
|
||
finished = command_take(IEC104_COMMAND_FINISHED);
|
||
CHECK(finished.reason == IEC104_COMMAND_FINISH_MISMATCH);
|
||
CHECK(finished.request.type_id == 63U && finished.request.value.short_float == -1.25f);
|
||
CHECK(finished.request.time_utc_ms == command_epoch_ms);
|
||
fake.send_blocked = 0U;
|
||
command_flush();
|
||
command_raw_reply_at(0U, selected, selected_length, 7U);
|
||
command_raw_reply_at(1U, rejected, selected_length, 0x6eU);
|
||
command_raw_reply_at(2U, executed, executed_length, 0x47U);
|
||
CHECK(command_frame_count() == 3U && !command_status.busy);
|
||
command_congest();
|
||
short_length = command_payload_bytes(short_reply, 45U, 6U, 0x63U, 2U, 6001U,
|
||
short_payload, sizeof(short_payload));
|
||
command_raw_send(short_reply, short_length);
|
||
command_process();
|
||
CHECK(command_status.pending_replies == 1U);
|
||
fake.send_blocked = 0U;
|
||
command_flush();
|
||
command_raw_reply_at(3U, short_reply, short_length, 0x6eU);
|
||
CHECK(command_frame_count() == 4U && command_action_calls == 0U);
|
||
command_empty();
|
||
command_close();
|
||
++command_checks;
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:所有时标长度独立验证SQ/尾部规范化及截断/多对象丢弃。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:地址错误优先于基准缺失。
|
||
*/
|
||
static void test_command_timed_wire_validation(void)
|
||
{
|
||
size_t index;
|
||
unsigned variant;
|
||
for (index = 0U; index < sizeof(command_timed_cases) / sizeof(command_timed_cases[0]); ++index) {
|
||
for (variant = 0U; variant < 8U; ++variant) {
|
||
IEC104_CommandConfig_t config;
|
||
uint8_t bytes[64];
|
||
size_t length, received;
|
||
unsigned expected = 0x47U;
|
||
command_timed_config(&config, command_timed_cases[index].type, 1000U);
|
||
command_open(&config);
|
||
length = command_timed_bytes(bytes, command_timed_cases[index].type, 6U, 0x61U, 1U, 6001U,
|
||
command_timed_cases[index].payload, command_timed_cases[index].payload_length, command_epoch_time);
|
||
received = length;
|
||
switch (variant) {
|
||
case 0U: bytes[1] = 0x81U; break;
|
||
case 1U: bytes[received++] = 0xa5U; break;
|
||
case 2U: --received; expected = 0U; break;
|
||
case 3U: bytes[1] = 0U; expected = 0U; break;
|
||
case 4U:
|
||
memcpy(bytes + length, bytes + 6U, length - 6U);
|
||
received += length - 6U;
|
||
bytes[1] = 2U;
|
||
expected = 0U;
|
||
break;
|
||
case 5U: bytes[2] = 5U; bytes[4] = 2U; expected = 0x6dU; break;
|
||
case 6U: bytes[4] = 2U; bytes[6] = bytes[7] = bytes[8] = 0U; expected = 0x6eU; break;
|
||
default: bytes[6] = bytes[7] = bytes[8] = 0U; expected = 0x6fU; break;
|
||
}
|
||
command_raw_send(bytes, received);
|
||
command_flush();
|
||
CHECK(command_frame_count() == (expected == 0U ? 0U : 1U));
|
||
if (expected != 0U) { command_raw_reply_at(0U, bytes, length, expected); }
|
||
CHECK(command_status.time_rejected == 0U && command_status.time_expired == 0U);
|
||
CHECK(command_action_calls == 0U && !command_status.busy);
|
||
command_empty();
|
||
command_close();
|
||
}
|
||
}
|
||
++command_checks;
|
||
}
|
||
|
||
/* ============================================================================
|
||
* [COMMAND/POINTS] 点表用例:默认掩码、空表、逐点模式、二分查点及身份
|
||
* ============================================================================ */
|
||
/**
|
||
* 功能:验证以下场景与约束:保持默认全局类型掩码,用显式测试点表逐一接入14类命令。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:点表令51/64直接执行,其余先选择;时标类无基准时拒绝,有基准后完成事务。
|
||
*/
|
||
static void test_command_default_all_types(void)
|
||
{
|
||
static const unsigned types[] = {45U, 46U, 47U, 48U, 49U, 50U, 51U,
|
||
58U, 59U, 60U, 61U, 62U, 63U, 64U};
|
||
static const uint8_t local_time[7] = {0U, 0U, 0U, 8U, 1U, 1U, 26U};
|
||
IEC104_CommandConfig_t defaults;
|
||
size_t index;
|
||
IEC104_Command_Config_Default(&defaults);
|
||
CHECK(defaults.type_mask == UINT16_C(0x3fff));
|
||
CHECK(defaults.points == NULL && defaults.point_count == 0U);
|
||
CHECK(defaults.time_tag_max_delay_ms == 10000U && defaults.master_utc_offset_minutes == 480);
|
||
CHECK(defaults.negative_on_expired);
|
||
for (index = 0U; index < sizeof(types) / sizeof(types[0]); ++index) {
|
||
unsigned type = types[index];
|
||
unsigned qualifier, reply_index = 0U;
|
||
bool timed = type >= 58U;
|
||
bool direct = type == 51U || type == 64U;
|
||
IEC104_CommandEvent_t event, finished;
|
||
uint8_t selected[32], executed[32], simple[1];
|
||
const uint8_t *payload;
|
||
size_t payload_length, length;
|
||
if (type <= 46U) {
|
||
simple[0] = type == 45U ? 1U : 2U;
|
||
payload = simple;
|
||
payload_length = sizeof(simple);
|
||
qualifier = 0U;
|
||
} else if (!timed) {
|
||
payload = command_value_cases[type - 47U].payload;
|
||
payload_length = command_value_cases[type - 47U].payload_length;
|
||
qualifier = command_value_cases[type - 47U].qualifier_offset;
|
||
} else {
|
||
payload = command_timed_cases[type - 58U].payload;
|
||
payload_length = command_timed_cases[type - 58U].payload_length;
|
||
qualifier = command_timed_cases[type - 58U].qualifier_offset;
|
||
}
|
||
command_config_mode(&defaults, direct ? IEC104_COMMAND_MODE_DIRECT : IEC104_COMMAND_MODE_SELECT_EXECUTE);
|
||
command_open(&defaults);
|
||
length = timed ? command_timed_bytes(executed, type, 6U, 0x51U, 1U, 6001U,
|
||
payload, payload_length, local_time) : command_payload_bytes(executed, type, 6U,
|
||
0x51U, 1U, 6001U, payload, payload_length);
|
||
memcpy(selected, executed, length);
|
||
if (!direct) { selected[9U + qualifier] |= 0x80U; }
|
||
if (timed) {
|
||
command_raw_send(selected, length);
|
||
command_flush();
|
||
CHECK(command_status.time_rejected == 1U && command_status.accepted == 0U);
|
||
CHECK(command_action_calls == 0U && !command_status.busy);
|
||
command_raw_reply_at(reply_index++, selected, length, 0x71U);
|
||
command_empty();
|
||
CHECK(IEC104_Command_Set_Time_Base(command, command_epoch_ms, fake.now));
|
||
}
|
||
if (!direct) {
|
||
command_raw_send(executed, length);
|
||
command_flush();
|
||
CHECK(command_status.accepted == 0U && command_action_calls == 0U);
|
||
command_raw_reply_at(reply_index++, executed, length, 0x47U);
|
||
command_empty();
|
||
command_raw_send(selected, length);
|
||
event = command_take(IEC104_COMMAND_SELECT);
|
||
CHECK(event.request.type_id == type && event.request.is_select);
|
||
CHECK(IEC104_Command_Accept(command, &event, NULL, NULL) == IEC104_COMMAND_REPLY_OK);
|
||
command_flush();
|
||
command_raw_reply_at(reply_index++, selected, length, 7U);
|
||
}
|
||
command_raw_send(executed, length);
|
||
event = command_take(IEC104_COMMAND_EXECUTE);
|
||
CHECK(event.request.type_id == type && !event.request.is_select);
|
||
CHECK(event.request.selected == !direct && event.request.has_time == timed);
|
||
if (type > 46U) { command_check_value(&event.request, type); }
|
||
else { CHECK(event.request.state == (type == 45U ? 1U : 2U)); }
|
||
if (timed) { CHECK(event.request.time_utc_ms == command_epoch_ms); }
|
||
CHECK(IEC104_Command_Accept(command, &event, command_action, &command_action_calls) == IEC104_COMMAND_REPLY_OK);
|
||
finished = command_done(&event, IEC104_COMMAND_RESULT_SUCCEEDED);
|
||
CHECK(command_action_calls == 1U && finished.request.type_id == type);
|
||
command_raw_reply_at(reply_index++, executed, length, 7U);
|
||
command_raw_reply_at(reply_index++, executed, length, 10U);
|
||
CHECK(command_frame_count() == reply_index);
|
||
command_close();
|
||
}
|
||
command_open(NULL);
|
||
command_send(105U, 6U, 0U, 1U, 0U, 1U);
|
||
CHECK(command_last_handled == IEC104_COMMAND_EVENT_IGNORED && command_frame_count() == 0U);
|
||
command_empty();
|
||
command_close();
|
||
++command_checks;
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:A raw default configuration has no points: all 14 enabled, valid types reach
|
||
* the unknown-IOA reply without publishing work or FINISHED.
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。
|
||
*/
|
||
static void test_command_point_default_empty(void)
|
||
{
|
||
static const unsigned types[] = {45U, 46U, 47U, 48U, 49U, 50U, 51U,
|
||
58U, 59U, 60U, 61U, 62U, 63U, 64U};
|
||
static const uint8_t local_time[7] = {0U, 0U, 0U, 8U, 1U, 1U, 26U};
|
||
size_t index;
|
||
for (index = 0U; index < sizeof(types) / sizeof(types[0]); ++index) {
|
||
IEC104_CommandConfig_t config;
|
||
uint8_t bytes[32], simple[1];
|
||
const uint8_t *payload;
|
||
size_t payload_length, length;
|
||
unsigned type = types[index];
|
||
IEC104_Command_Config_Default(&config);
|
||
CHECK(config.type_mask == UINT16_C(0x3fff));
|
||
CHECK(config.points == NULL && config.point_count == 0U);
|
||
command_open(&config);
|
||
CHECK(IEC104_Command_Set_Time_Base(command, command_epoch_ms, fake.now));
|
||
if (type <= 46U) {
|
||
simple[0] = type == 45U ? 1U : 2U;
|
||
payload = simple; payload_length = sizeof(simple);
|
||
} else if (type < 58U) {
|
||
payload = command_value_cases[type - 47U].payload;
|
||
payload_length = command_value_cases[type - 47U].payload_length;
|
||
} else {
|
||
payload = command_timed_cases[type - 58U].payload;
|
||
payload_length = command_timed_cases[type - 58U].payload_length;
|
||
}
|
||
length = type >= 58U ? command_timed_bytes(bytes, type, 6U, 0x51U, 1U, 6001U,
|
||
payload, payload_length, local_time) : command_payload_bytes(bytes, type, 6U,
|
||
0x51U, 1U, 6001U, payload, payload_length);
|
||
command_raw_send(bytes, length); command_flush();
|
||
CHECK(command_last_handled == IEC104_COMMAND_EVENT_HANDLED);
|
||
CHECK(command_status.rejected == 1U && command_status.accepted == 0U);
|
||
CHECK(!command_status.busy && command_action_calls == 0U);
|
||
CHECK(command_frame_count() == 1U);
|
||
command_raw_reply_at(0U, bytes, length, 0x6fU);
|
||
command_empty(); command_close();
|
||
}
|
||
++command_checks;
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:Validate the entire borrowed table before binding, including entries whose
|
||
* type bits are currently disabled globally. Mutations occur only unbound.
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。
|
||
*/
|
||
static void test_command_point_configuration(void)
|
||
{
|
||
static const IEC104_CommandPoint_t valid[] = {
|
||
{1U, 1U, IEC104_COMMAND_TYPE_BIT(45U), IEC104_COMMAND_MODE_SELECT_EXECUTE},
|
||
{1U, UINT32_C(0xffffff), IEC104_COMMAND_TYPE_BIT(51U), IEC104_COMMAND_MODE_DIRECT},
|
||
{65534U, UINT32_C(0xffffff), IEC104_COMMAND_TYPE_BIT(64U), IEC104_COMMAND_MODE_DIRECT}
|
||
};
|
||
IEC104_CommandConfig_t config;
|
||
IEC104_CommandPoint_t points[3];
|
||
unsigned variant;
|
||
command_open(NULL);
|
||
CHECK(IEC104_Command_Destroy(command));
|
||
for (variant = 0U; variant < 17U; ++variant) {
|
||
IEC104_Command_Config_Default(&config);
|
||
config.type_mask = IEC104_COMMAND_TYPE_BIT(45U);
|
||
memcpy(points, valid, sizeof(points));
|
||
config.points = points; config.point_count = 3U;
|
||
switch (variant) {
|
||
case 0U: points[0].common_address = 0U; break;
|
||
case 1U: points[2].common_address = 65535U; break;
|
||
case 2U: points[0].ioa = 0U; break;
|
||
case 3U: points[2].ioa = UINT32_C(0x1000000); break;
|
||
case 4U: points[0].type_mask = 0U; break;
|
||
case 5U: points[0].type_mask |= UINT16_C(0x4000); break;
|
||
case 6U: points[2].type_mask |= UINT16_C(0x8000); break;
|
||
case 7U: points[0].mode = (IEC104_CommandMode_t)0; break;
|
||
case 8U: points[2].mode = (IEC104_CommandMode_t)3; break;
|
||
case 9U: points[1].ioa = points[0].ioa; break;
|
||
case 10U: points[0].ioa = 2U; points[1].ioa = 1U; break;
|
||
case 11U: points[0].common_address = 2U; break;
|
||
case 12U: points[1].mode = IEC104_COMMAND_MODE_SELECT_EXECUTE; break;
|
||
case 13U: points[2].mode = IEC104_COMMAND_MODE_SELECT_EXECUTE; break;
|
||
case 14U: config.points = NULL; break;
|
||
case 15U: config.point_count = 0U; break;
|
||
default: config.point_count = SIZE_MAX; break;
|
||
}
|
||
CHECK(IEC104_Command_Create(command_slave, &config) == NULL);
|
||
}
|
||
IEC104_Command_Config_Default(&config);
|
||
config.type_mask = IEC104_COMMAND_TYPE_BIT(45U);
|
||
config.points = valid; config.point_count = sizeof(valid) / sizeof(valid[0]);
|
||
command = IEC104_Command_Create(command_slave, &config);
|
||
CHECK(command != NULL);
|
||
command_close();
|
||
++command_checks;
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:The same type can have different modes at two IOAs or at equal IOAs in two
|
||
* stations. Policy rejections never borrow a transaction or call application.
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。
|
||
*/
|
||
static void test_command_point_modes(void)
|
||
{
|
||
static const IEC104_CommandPoint_t points[] = {
|
||
{1U, 6001U, IEC104_COMMAND_TYPE_BIT(45U), IEC104_COMMAND_MODE_DIRECT},
|
||
{1U, 6002U, IEC104_COMMAND_TYPE_BIT(45U), IEC104_COMMAND_MODE_SELECT_EXECUTE},
|
||
{1U, 6003U, IEC104_COMMAND_TYPE_BIT(46U), IEC104_COMMAND_MODE_DIRECT},
|
||
{2U, 6001U, IEC104_COMMAND_TYPE_BIT(45U), IEC104_COMMAND_MODE_SELECT_EXECUTE},
|
||
{2U, 6002U, IEC104_COMMAND_TYPE_BIT(46U), IEC104_COMMAND_MODE_DIRECT}
|
||
};
|
||
static const struct { unsigned ca, ioa, value, event, cause; } cases[] = {
|
||
{1U, 6001U, 0x81U, 0U, 0x47U}, {1U, 6001U, 1U, IEC104_COMMAND_EXECUTE, 7U},
|
||
{1U, 6002U, 1U, 0U, 0x47U}, {1U, 6002U, 0x81U, IEC104_COMMAND_SELECT, 7U},
|
||
{2U, 6001U, 1U, 0U, 0x47U}, {2U, 6001U, 0x81U, IEC104_COMMAND_SELECT, 7U},
|
||
{1U, 6003U, 1U, 0U, 0x47U}, {2U, 6002U, 0x81U, 0U, 0x47U},
|
||
{1U, 6004U, 1U, 0U, 0x6fU}, {2U, 6003U, 0x81U, 0U, 0x6fU}
|
||
};
|
||
size_t index;
|
||
for (index = 0U; index < sizeof(cases) / sizeof(cases[0]); ++index) {
|
||
IEC104_CommandConfig_t config;
|
||
IEC104_Station_t other = {0};
|
||
IEC104_CommandEvent_t event;
|
||
IEC104_Command_Config_Default(&config);
|
||
config.points = points; config.point_count = sizeof(points) / sizeof(points[0]);
|
||
command_open(&config);
|
||
CHECK(IEC104_Slave_Add_Station(command_slave, &other, 2U, &other) == IEC104_STATION_OK);
|
||
/* Config is copied; the original const table remains alive and unchanged. */
|
||
config.points = NULL; config.point_count = 0U; config.type_mask = 0U;
|
||
command_send(45U, 6U, 0x51U, cases[index].ca, cases[index].ioa, cases[index].value);
|
||
if (cases[index].event != 0U) {
|
||
event = command_take((IEC104_CommandEventType_t)cases[index].event);
|
||
CHECK(event.request.common_address == cases[index].ca && event.request.ioa == cases[index].ioa);
|
||
CHECK(!event.request.selected);
|
||
CHECK(IEC104_Command_Accept(command, &event, command_action, &command_action_calls) == IEC104_COMMAND_REPLY_OK);
|
||
if (event.type == IEC104_COMMAND_EXECUTE) { (void)command_done(&event, IEC104_COMMAND_RESULT_SUCCEEDED); }
|
||
else {
|
||
command_flush(); IEC104_Command_Cancel(command);
|
||
CHECK(command_take(IEC104_COMMAND_FINISHED).reason == IEC104_COMMAND_FINISH_CANCELLED);
|
||
}
|
||
CHECK(command_action_calls == 1U);
|
||
} else {
|
||
command_flush(); command_empty();
|
||
CHECK(command_status.rejected == 1U && command_status.accepted == 0U);
|
||
CHECK(!command_status.busy && command_status.busy_rejected == 0U && command_action_calls == 0U);
|
||
CHECK(command_frame_count() == 1U);
|
||
IEC104_Command_Cancel(command); command_empty();
|
||
}
|
||
command_reply_at(0U, 45U, cases[index].cause, 0x51U, cases[index].ca,
|
||
cases[index].ioa, cases[index].value);
|
||
CHECK(IEC104_Slave_Remove_Station(command_slave, &other) == IEC104_STATION_OK);
|
||
command_empty(); command_close();
|
||
CHECK(IEC104_Station_Is_Reusable(&other));
|
||
}
|
||
++command_checks;
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:A point may name globally disabled types, but global disable still produces
|
||
* IGNORED for activation/deactivation. An enabled type absent from a known
|
||
* point produces negative 7/9。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:it is a point policy, not an unknown type.
|
||
*/
|
||
static void test_command_point_type_intersection(void)
|
||
{
|
||
static const IEC104_CommandPoint_t points[] = {
|
||
{1U, 6001U, IEC104_COMMAND_TYPE_BIT(45U) | IEC104_COMMAND_TYPE_BIT(46U), IEC104_COMMAND_MODE_DIRECT},
|
||
{1U, 6002U, IEC104_COMMAND_TYPE_BIT(46U), IEC104_COMMAND_MODE_DIRECT}
|
||
};
|
||
IEC104_CommandConfig_t config;
|
||
IEC104_CommandEvent_t event;
|
||
unsigned ioa;
|
||
IEC104_Command_Config_Default(&config);
|
||
config.type_mask = IEC104_COMMAND_TYPE_BIT(45U);
|
||
config.points = points; config.point_count = sizeof(points) / sizeof(points[0]);
|
||
command_open(&config);
|
||
for (ioa = 6001U; ioa <= 6003U; ++ioa) {
|
||
command_send(46U, 6U, 0x51U, 1U, ioa, 2U);
|
||
CHECK(command_last_handled == IEC104_COMMAND_EVENT_IGNORED);
|
||
command_send(46U, 8U, 0x51U, 1U, ioa, 2U);
|
||
CHECK(command_last_handled == IEC104_COMMAND_EVENT_IGNORED);
|
||
}
|
||
command_flush(); command_empty();
|
||
CHECK(command_status.rejected == 0U && command_frame_count() == 0U);
|
||
command_send(45U, 6U, 0x51U, 1U, 6002U, 1U); command_flush();
|
||
command_reply_at(0U, 45U, 0x47U, 0x51U, 1U, 6002U, 1U);
|
||
command_empty(); CHECK(command_action_calls == 0U && !command_status.busy);
|
||
command_send(45U, 8U, 0x51U, 1U, 6002U, 1U); command_flush();
|
||
command_reply_at(1U, 45U, 0x49U, 0x51U, 1U, 6002U, 1U);
|
||
command_empty(); CHECK(command_action_calls == 0U && !command_status.busy);
|
||
event = command_execute(45U, 1U);
|
||
(void)command_done(&event, IEC104_COMMAND_RESULT_SUCCEEDED);
|
||
CHECK(command_status.accepted == 1U && command_status.rejected == 2U);
|
||
CHECK(command_action_calls == 1U && command_frame_count() == 4U);
|
||
command_close();
|
||
++command_checks;
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:Pending same-point activation and selected-command matching precede point
|
||
* policy。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:policy itself precedes busy. Cancellation still uses transaction identity.
|
||
*/
|
||
static void test_command_point_ordering(void)
|
||
{
|
||
static const IEC104_CommandPoint_t points[] = {
|
||
{1U, 6001U, IEC104_COMMAND_TYPE_BIT(45U), IEC104_COMMAND_MODE_SELECT_EXECUTE},
|
||
{1U, 6002U, IEC104_COMMAND_TYPE_BIT(45U), IEC104_COMMAND_MODE_DIRECT}
|
||
};
|
||
unsigned phase;
|
||
for (phase = 0U; phase < 3U; ++phase) {
|
||
IEC104_CommandConfig_t config;
|
||
IEC104_CommandEvent_t event, finished;
|
||
IEC104_CommandTransactionInfo_t info;
|
||
unsigned ioa = phase == 2U ? 6002U : 6001U;
|
||
IEC104_Command_Config_Default(&config);
|
||
config.points = points; config.point_count = sizeof(points) / sizeof(points[0]);
|
||
command_open(&config);
|
||
command_send(45U, 6U, 0x51U, 1U, ioa, phase == 2U ? 1U : 0x81U);
|
||
event = command_take(phase == 2U ? IEC104_COMMAND_EXECUTE : IEC104_COMMAND_SELECT);
|
||
if (phase == 1U) {
|
||
CHECK(IEC104_Command_Accept(command, &event, NULL, NULL) == IEC104_COMMAND_REPLY_OK);
|
||
command_flush();
|
||
}
|
||
/* Type 46 is globally enabled but absent from this point. */
|
||
command_send(46U, 6U, 0x51U, 1U, ioa, 2U); command_flush();
|
||
if (phase == 1U) {
|
||
command_reply_at(1U, 46U, 0x47U, 0x51U, 1U, ioa, 2U);
|
||
finished = command_take(IEC104_COMMAND_FINISHED);
|
||
CHECK(finished.reason == IEC104_COMMAND_FINISH_MISMATCH);
|
||
CHECK(finished.transaction_id == event.transaction_id && command_status.mismatches == 1U);
|
||
CHECK(command_status.dropped_requests == 0U && command_frame_count() == 2U);
|
||
} else {
|
||
CHECK(command_status.dropped_requests == 1U && command_status.rejected == 0U);
|
||
CHECK(command_frame_count() == 0U);
|
||
if (phase == 2U) {
|
||
command_send(45U, 6U, 0x51U, 1U, ioa, 0x81U); command_flush();
|
||
CHECK(command_status.dropped_requests == 2U && command_status.rejected == 0U);
|
||
}
|
||
CHECK(IEC104_Command_Get_Transaction(command, &event, &info) && info.active);
|
||
command_send(45U, 6U, 0x51U, 1U, 6003U, 1U); command_flush();
|
||
command_reply_at(0U, 45U, 0x6fU, 0x51U, 1U, 6003U, 1U);
|
||
CHECK(command_status.busy_rejected == 0U);
|
||
command_send(46U, 6U, 0x51U, 1U, phase == 2U ? 6001U : 6002U, 2U); command_flush();
|
||
command_reply_at(1U, 46U, 0x47U, 0x51U, 1U, phase == 2U ? 6001U : 6002U, 2U);
|
||
CHECK(command_status.busy_rejected == 0U);
|
||
command_send(45U, 6U, 0x51U, 1U, phase == 2U ? 6001U : 6002U, phase == 2U ? 0x81U : 1U);
|
||
command_flush();
|
||
CHECK(command_status.busy_rejected == 1U && command_status.rejected == 3U);
|
||
command_send(45U, 8U, 0x51U, 1U, ioa, 0U); command_flush();
|
||
command_reply_at(3U, 45U, 9U, 0x51U, 1U, ioa, 0U);
|
||
finished = command_take(IEC104_COMMAND_FINISHED);
|
||
CHECK(finished.reason == IEC104_COMMAND_FINISH_DEACTIVATED);
|
||
CHECK(finished.transaction_id == event.transaction_id && command_frame_count() == 4U);
|
||
}
|
||
CHECK(command_action_calls == 0U);
|
||
command_empty(); command_close();
|
||
}
|
||
{
|
||
IEC104_CommandConfig_t config;
|
||
uint8_t bytes[32];
|
||
static const uint8_t payload[1] = {1U};
|
||
size_t length;
|
||
command_timed_config(&config, 58U, 1000U);
|
||
/* 静默过期先于点表拒绝:无新增回复证明不会落入未知IOA/类型拒绝。 */
|
||
config.negative_on_expired = false;
|
||
config.points = points; config.point_count = sizeof(points) / sizeof(points[0]);
|
||
command_open(&config);
|
||
length = command_timed_bytes(bytes, 58U, 6U, 0x51U, 1U, 6003U,
|
||
payload, sizeof(payload), command_epoch_time);
|
||
command_raw_send(bytes, length); command_flush();
|
||
command_raw_reply_at(0U, bytes, length, 0x71U);
|
||
CHECK(command_status.time_rejected == 1U);
|
||
CHECK(IEC104_Command_Set_Time_Base(command, command_epoch_ms + 1000U, fake.now));
|
||
command_raw_send(bytes, length); command_flush();
|
||
CHECK(command_status.time_expired == 1U && command_frame_count() == 1U);
|
||
CHECK(IEC104_Command_Set_Time_Base(command, command_epoch_ms, fake.now));
|
||
command_raw_send(bytes, length); command_flush();
|
||
command_raw_reply_at(1U, bytes, length, 0x6fU);
|
||
bytes[6] -= 2U;
|
||
command_raw_send(bytes, length); command_flush();
|
||
command_raw_reply_at(2U, bytes, length, 0x47U);
|
||
CHECK(command_status.rejected == 3U && command_status.time_rejected == 1U);
|
||
CHECK(command_status.accepted == 0U && !command_status.busy && command_action_calls == 0U);
|
||
command_empty(); command_close();
|
||
}
|
||
++command_checks;
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:Binary lookup must distinguish both CA and all 24 IOA bits at first, middle,
|
||
* last and missing keys. The table may precede station registration.
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。
|
||
*/
|
||
static void test_command_point_lookup_boundaries(void)
|
||
{
|
||
static const IEC104_CommandPoint_t points[] = {
|
||
{1U, 1U, IEC104_COMMAND_TYPE_BIT(45U), IEC104_COMMAND_MODE_DIRECT},
|
||
{1U, 6001U, IEC104_COMMAND_TYPE_BIT(46U), IEC104_COMMAND_MODE_DIRECT},
|
||
{1U, UINT32_C(0xffffff), IEC104_COMMAND_TYPE_BIT(45U), IEC104_COMMAND_MODE_DIRECT},
|
||
{65534U, 1U, IEC104_COMMAND_TYPE_BIT(46U), IEC104_COMMAND_MODE_DIRECT},
|
||
{65534U, UINT32_C(0xffffff), IEC104_COMMAND_TYPE_BIT(45U), IEC104_COMMAND_MODE_DIRECT}
|
||
};
|
||
static const struct { unsigned ca, ioa, type, cause; } cases[] = {
|
||
{1U, 1U, 45U, 7U}, {1U, 6001U, 46U, 7U}, {1U, 0xffffffU, 45U, 7U},
|
||
{65534U, 1U, 46U, 7U}, {65534U, 0xffffffU, 45U, 7U},
|
||
{1U, 2U, 45U, 0x6fU}, {1U, 6000U, 45U, 0x6fU},
|
||
{65534U, 0xfffffeU, 45U, 0x6fU}, {65534U, 6001U, 45U, 0x6fU},
|
||
{65533U, 1U, 45U, 0x6eU}
|
||
};
|
||
size_t index;
|
||
for (index = 0U; index < sizeof(cases) / sizeof(cases[0]); ++index) {
|
||
IEC104_CommandConfig_t config;
|
||
IEC104_Station_t other = {0};
|
||
unsigned value = cases[index].type == 45U ? 1U : 2U;
|
||
IEC104_Command_Config_Default(&config);
|
||
config.points = points; config.point_count = sizeof(points) / sizeof(points[0]);
|
||
command_open(&config);
|
||
CHECK(IEC104_Slave_Add_Station(command_slave, &other, 65534U, &other) == IEC104_STATION_OK);
|
||
command_send(cases[index].type, 6U, 0x51U, cases[index].ca, cases[index].ioa, value);
|
||
if (cases[index].cause == 7U) {
|
||
IEC104_CommandEvent_t event = command_take(IEC104_COMMAND_EXECUTE);
|
||
CHECK(event.request.ioa == cases[index].ioa && event.request.common_address == cases[index].ca);
|
||
CHECK(IEC104_Command_Accept(command, &event, command_action, &command_action_calls) == IEC104_COMMAND_REPLY_OK);
|
||
(void)command_done(&event, IEC104_COMMAND_RESULT_SUCCEEDED);
|
||
CHECK(command_action_calls == 1U);
|
||
} else {
|
||
command_flush(); command_empty();
|
||
CHECK(command_action_calls == 0U && command_status.accepted == 0U && !command_status.busy);
|
||
}
|
||
command_reply_at(0U, cases[index].type, cases[index].cause, 0x51U,
|
||
cases[index].ca, cases[index].ioa, value);
|
||
CHECK(IEC104_Slave_Remove_Station(command_slave, &other) == IEC104_STATION_OK);
|
||
command_close();
|
||
CHECK(IEC104_Station_Is_Reusable(&other));
|
||
}
|
||
++command_checks;
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:Ending a selection cannot transfer its permission to another IOA or a new
|
||
* station registration. The immutable table remains usable after every end.
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。
|
||
*/
|
||
static void test_command_point_lifetime(void)
|
||
{
|
||
static const IEC104_CommandPoint_t points[] = {
|
||
{1U, 6001U, IEC104_COMMAND_TYPE_BIT(45U), IEC104_COMMAND_MODE_SELECT_EXECUTE},
|
||
{1U, 6002U, IEC104_COMMAND_TYPE_BIT(45U), IEC104_COMMAND_MODE_DIRECT}
|
||
};
|
||
unsigned ending;
|
||
for (ending = 0U; ending < 3U; ++ending) {
|
||
IEC104_CommandConfig_t config;
|
||
IEC104_CommandEvent_t selected, event, finished;
|
||
IEC104_Station_t replacement = {0};
|
||
unsigned reply_index = 1U;
|
||
IEC104_Command_Config_Default(&config);
|
||
config.points = points; config.point_count = sizeof(points) / sizeof(points[0]);
|
||
config.select_timeout_ms = 10U;
|
||
command_open(&config);
|
||
command_send(45U, 6U, 0x51U, 1U, 6001U, 0x81U);
|
||
selected = command_take(IEC104_COMMAND_SELECT);
|
||
CHECK(IEC104_Command_Accept(command, &selected, NULL, NULL) == IEC104_COMMAND_REPLY_OK);
|
||
command_flush();
|
||
if (ending == 0U) { fake.now += 10U; command_flush(); }
|
||
else if (ending == 1U) { push(stop_act, sizeof(stop_act)); command_poll(); }
|
||
else {
|
||
CHECK(IEC104_Slave_Remove_Station(command_slave, &command_station) == IEC104_STATION_OK);
|
||
CHECK(IEC104_Slave_Add_Station(command_slave, &replacement, 1U, &replacement) == IEC104_STATION_OK);
|
||
command_send(45U, 6U, 0x51U, 1U, 6001U, 1U); command_flush();
|
||
command_reply_at(reply_index++, 45U, 0x47U, 0x51U, 1U, 6001U, 1U);
|
||
CHECK(command_status.mismatches == 0U && command_status.busy_rejected == 1U);
|
||
IEC104_Command_Cancel(command);
|
||
}
|
||
finished = command_take(IEC104_COMMAND_FINISHED);
|
||
CHECK(finished.reason == (ending == 0U ? IEC104_COMMAND_FINISH_SELECT_TIMEOUT :
|
||
(ending == 1U ? IEC104_COMMAND_FINISH_STOPPED : IEC104_COMMAND_FINISH_CANCELLED)));
|
||
CHECK(finished.request.station_id == selected.request.station_id);
|
||
CHECK(IEC104_Command_Accept(command, &selected, command_action, &command_action_calls) == IEC104_COMMAND_REPLY_STALE);
|
||
if (ending == 1U) { push(start_act, sizeof(start_act)); command_poll(); }
|
||
command_send(45U, 6U, 0x51U, 1U, 6001U, 1U); command_flush();
|
||
command_reply_at(reply_index++, 45U, 0x47U, 0x51U, 1U, 6001U, 1U);
|
||
command_empty(); CHECK(command_action_calls == 0U && !command_status.busy);
|
||
command_send(45U, 6U, 0x51U, 1U, 6002U, 1U);
|
||
event = command_take(IEC104_COMMAND_EXECUTE);
|
||
CHECK(!event.request.selected && event.transaction_id != selected.transaction_id);
|
||
CHECK((event.request.station_id == selected.request.station_id) == (ending != 2U));
|
||
CHECK(IEC104_Command_Accept(command, &event, command_action, &command_action_calls) == IEC104_COMMAND_REPLY_OK);
|
||
(void)command_done(&event, IEC104_COMMAND_RESULT_SUCCEEDED);
|
||
command_reply_at(reply_index++, 45U, 7U, 0x51U, 1U, 6002U, 1U);
|
||
command_reply_at(reply_index++, 45U, 10U, 0x51U, 1U, 6002U, 1U);
|
||
CHECK(command_frame_count() == reply_index && command_action_calls == 1U);
|
||
if (ending == 2U) {
|
||
CHECK(IEC104_Station_Is_Reusable(&command_station));
|
||
CHECK(IEC104_Slave_Remove_Station(command_slave, &replacement) == IEC104_STATION_OK);
|
||
}
|
||
command_close();
|
||
CHECK(IEC104_Station_Is_Reusable(&replacement));
|
||
}
|
||
++command_checks;
|
||
}
|
||
|
||
/* ============================================================================
|
||
* [COMMAND/RETURNS] 应答收尾用例:持续突发、返回信息与交接寿命
|
||
* ============================================================================ */
|
||
/**
|
||
* 功能:验证以下场景与约束:用k=1及一个未ACK填充帧把事务回复留在HIGH,交叉覆盖有/无返校及成功/失败终止。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:FINISHED以事务最后一帧被HANDED为界;仅Send_Response接手OK还不能提前完成。
|
||
*/
|
||
static void test_command_response_tail(void)
|
||
{
|
||
unsigned has_return, success;
|
||
for (has_return = 0U; has_return <= 1U; ++has_return) {
|
||
for (success = 0U; success <= 1U; ++success) {
|
||
IEC104_CommandConfig_t config;
|
||
IEC104_CommandEvent_t event, finished;
|
||
IEC60870_Asdu_t data;
|
||
uint8_t bytes[10];
|
||
uint8_t filler[] = {200U, 0U, 3U, 0U, 1U, 0U};
|
||
unsigned handed, replies = 2U + has_return;
|
||
command_config_default(&config); command_config_mode(&config, IEC104_COMMAND_MODE_DIRECT);
|
||
command_window = 1U; command_open(&config);
|
||
CHECK(IEC60870_Asdu_Create_From_Buffer(&data,
|
||
IEC104_Slave_Get_Application_Layer_Parameters(command_slave), filler, sizeof(filler)) == IEC60870_ASDU_OK);
|
||
CHECK(IEC104_Slave_Enqueue_Event(command_slave, &data) == IEC104_TCP_SUBMIT_OK);
|
||
command_poll();
|
||
event = command_execute(45U, 1U);
|
||
CHECK(IEC104_Command_Report_Result(command, &event,
|
||
success ? IEC104_COMMAND_RESULT_SUCCEEDED : IEC104_COMMAND_RESULT_FAILED) == IEC104_COMMAND_REPLY_OK);
|
||
if (has_return != 0U) {
|
||
command_return(&data, bytes, 1U, 1U);
|
||
CHECK(IEC104_Command_Submit_Return_Info(command, &event, &data) == IEC104_COMMAND_REPLY_OK);
|
||
}
|
||
CHECK(IEC104_Command_Complete(command, &event) == IEC104_COMMAND_REPLY_OK);
|
||
command_process(); command_empty();
|
||
CHECK(command_status.busy && command_frame_count() == 0U);
|
||
for (handed = 1U; handed <= replies; ++handed) {
|
||
push_ack((uint16_t)handed); command_poll(); command_flush();
|
||
CHECK(command_frame_count() == handed);
|
||
if (handed < replies) { command_empty(); CHECK(command_status.busy); }
|
||
}
|
||
finished = command_take(IEC104_COMMAND_FINISHED);
|
||
CHECK(finished.reason == (success ? IEC104_COMMAND_FINISH_COMPLETED : IEC104_COMMAND_FINISH_EXECUTION_FAILED));
|
||
CHECK(!finished.return_info_undelivered);
|
||
command_reply_at(replies - 1U, 45U, success ? 10U : 0x4aU, 0x51U, 1U, 6001U, 1U);
|
||
CHECK(command_action_calls == 1U && command_status.return_info_undelivered == 0U);
|
||
command_close();
|
||
}
|
||
}
|
||
++command_checks;
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:保持NORMAL始终有积压,k=1下每次ACK只腾出一个发送窗口。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:确认、返校和终止仍须经HIGH依次推进;检查结束时NORMAL尚有待发帧,
|
||
* 排除“先排空突发才能完成遥控”的旧屏障行为。
|
||
*/
|
||
static void test_command_continuous_events(void)
|
||
{
|
||
IEC104_CommandConfig_t config;
|
||
IEC104_CommandEvent_t event, finished;
|
||
IEC104_AsduQueueStatus_t queues;
|
||
IEC60870_Asdu_t filler, data;
|
||
uint8_t filler_bytes[] = {200U, 0U, 3U, 0U, 1U, 0U};
|
||
uint8_t data_bytes[10];
|
||
unsigned index;
|
||
command_config_default(&config); command_config_mode(&config, IEC104_COMMAND_MODE_DIRECT);
|
||
command_window = 1U; command_open(&config);
|
||
CHECK(IEC60870_Asdu_Create_From_Buffer(&filler,
|
||
IEC104_Slave_Get_Application_Layer_Parameters(command_slave),
|
||
filler_bytes, sizeof(filler_bytes)) == IEC60870_ASDU_OK);
|
||
for (index = 0U; index < 12U; ++index) {
|
||
CHECK(IEC104_Slave_Enqueue_Event(command_slave, &filler) == IEC104_TCP_SUBMIT_OK);
|
||
}
|
||
event = command_execute(45U, 1U);
|
||
CHECK(IEC104_Command_Report_Result(command, &event, IEC104_COMMAND_RESULT_SUCCEEDED) == IEC104_COMMAND_REPLY_OK);
|
||
command_return(&data, data_bytes, 1U, 1U);
|
||
CHECK(IEC104_Command_Submit_Return_Info(command, &event, &data) == IEC104_COMMAND_REPLY_OK);
|
||
CHECK(IEC104_Command_Complete(command, &event) == IEC104_COMMAND_REPLY_OK);
|
||
command_process(); command_empty();
|
||
for (index = 1U; index <= 4U && command_frame_count() < 3U; ++index) {
|
||
CHECK(IEC104_Slave_Enqueue_Event(command_slave, &filler) == IEC104_TCP_SUBMIT_OK);
|
||
push_ack((uint16_t)index); command_poll(); command_flush();
|
||
}
|
||
CHECK(command_frame_count() == 3U);
|
||
command_reply_at(0U, 45U, 7U, 0x51U, 1U, 6001U, 1U);
|
||
command_reply_at(1U, 1U, 11U, 0x51U, 1U, 1001U, 1U);
|
||
command_reply_at(2U, 45U, 10U, 0x51U, 1U, 6001U, 1U);
|
||
CHECK(IEC104_AsduQueue_Get_Status(&sut->queue, &queues) == IEC104_ASDU_QUEUE_OK);
|
||
CHECK(queues.entry_count[IEC104_ASDU_PRIORITY_NORMAL] >
|
||
queues.retained_unacked_count[IEC104_ASDU_PRIORITY_NORMAL]);
|
||
finished = command_take(IEC104_COMMAND_FINISHED);
|
||
CHECK(finished.reason == IEC104_COMMAND_FINISH_COMPLETED && !finished.return_info_undelivered);
|
||
command_close();
|
||
++command_checks;
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:异常终结时冻结返校交付快照,不能等应用读取FINISHED才重新查询。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:六种模式覆盖STOP、EOF、Cancel、Close、仅TERM未交付,以及两条返校只交付首条。
|
||
* Cancel后已接手的返校仍可能发出,但不能追改已冻结的undelivered结果。
|
||
*/
|
||
static void test_command_return_lifetime(void)
|
||
{
|
||
unsigned mode;
|
||
for (mode = 0U; mode < 6U; ++mode) {
|
||
IEC104_CommandConfig_t config;
|
||
IEC104_CommandEvent_t event, finished;
|
||
IEC60870_Asdu_t data;
|
||
uint8_t bytes[10];
|
||
bool undelivered = mode != 4U;
|
||
command_config_default(&config); command_config_mode(&config, IEC104_COMMAND_MODE_DIRECT);
|
||
command_window = 1U; command_open(&config);
|
||
event = command_execute(45U, 1U);
|
||
CHECK(IEC104_Command_Report_Result(command, &event, IEC104_COMMAND_RESULT_SUCCEEDED) == IEC104_COMMAND_REPLY_OK);
|
||
command_return(&data, bytes, 1U, 1U);
|
||
CHECK(IEC104_Command_Submit_Return_Info(command, &event, &data) == IEC104_COMMAND_REPLY_OK);
|
||
if (mode == 5U) {
|
||
command_return(&data, bytes, 1U, 0U);
|
||
CHECK(IEC104_Command_Submit_Return_Info(command, &event, &data) == IEC104_COMMAND_REPLY_OK);
|
||
}
|
||
CHECK(IEC104_Command_Complete(command, &event) == IEC104_COMMAND_REPLY_OK);
|
||
command_process(); command_empty();
|
||
if (mode >= 4U) {
|
||
push_ack(1U); command_poll(); command_flush();
|
||
CHECK(command_frame_count() == 2U); command_empty();
|
||
}
|
||
if (mode == 1U) { fake.recv_eof = 1U; command_poll(); fake.recv_eof = 0U; }
|
||
else if (mode == 2U) {
|
||
IEC104_Command_Cancel(command);
|
||
/* Finish freezes PENDING before the old HIGH frame later hands off. */
|
||
push_ack(1U); command_poll(); command_flush();
|
||
CHECK(command_frame_count() == 2U);
|
||
} else if (mode == 3U) {
|
||
CHECK(IEC104_Slave_Close(command_slave, NULL) == IEC104_TCP_OK);
|
||
command_drain_transport();
|
||
} else { push(stop_act, sizeof(stop_act)); command_poll(); }
|
||
CHECK(IEC104_Command_Get_Status(command, &command_status));
|
||
CHECK(command_status.return_info_undelivered == (undelivered ? 1U : 0U));
|
||
finished = command_take(IEC104_COMMAND_FINISHED);
|
||
CHECK(finished.reason == (mode == 2U ? IEC104_COMMAND_FINISH_CANCELLED :
|
||
(mode == 1U || mode == 3U ? IEC104_COMMAND_FINISH_DISCONNECTED : IEC104_COMMAND_FINISH_STOPPED)));
|
||
CHECK(finished.return_info_undelivered == undelivered);
|
||
CHECK(command_action_calls == 1U);
|
||
command_close();
|
||
}
|
||
/* A normal completion is already frozen before Close retires all tickets. */
|
||
{
|
||
IEC104_CommandConfig_t config;
|
||
IEC104_CommandEvent_t event, finished;
|
||
IEC60870_Asdu_t data;
|
||
uint8_t bytes[10];
|
||
command_config_default(&config); command_config_mode(&config, IEC104_COMMAND_MODE_DIRECT);
|
||
command_open(&config); event = command_execute(45U, 1U);
|
||
command_return(&data, bytes, 1U, 1U);
|
||
CHECK(IEC104_Command_Submit_Return_Info(command, &event, &data) == IEC104_COMMAND_REPLY_OK);
|
||
CHECK(IEC104_Command_Report_Result(command, &event, IEC104_COMMAND_RESULT_SUCCEEDED) == IEC104_COMMAND_REPLY_OK);
|
||
CHECK(IEC104_Command_Complete(command, &event) == IEC104_COMMAND_REPLY_OK);
|
||
command_flush();
|
||
CHECK(IEC104_Slave_Close(command_slave, NULL) == IEC104_TCP_OK);
|
||
command_drain_transport();
|
||
finished = command_take(IEC104_COMMAND_FINISHED);
|
||
CHECK(finished.reason == IEC104_COMMAND_FINISH_COMPLETED && !finished.return_info_undelivered);
|
||
CHECK(IEC104_Command_Get_Status(command, &command_status) && command_status.return_info_undelivered == 0U);
|
||
command_close();
|
||
}
|
||
++command_checks;
|
||
}
|
||
|
||
/* ============================================================================
|
||
* [COMMAND/ADMISSION] 动作前准入:HIGH余量、旧回复门禁与查询失败
|
||
* ============================================================================ */
|
||
/**
|
||
* 功能:先用最大填充帧占住当前发送,再按HIGH头开销计算第二帧长度,留下精确room字节。
|
||
* 输入参数:room——需保留的 HIGH 空间(字节)。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:用真实队列构造边界,不覆盖状态快照;11/12字节分别不足/刚够45类确认。
|
||
*/
|
||
static void command_leave_high_room(size_t room)
|
||
{
|
||
uint8_t bytes[249] = {200U, 0U, 3U, 0U, 1U, 0U};
|
||
IEC60870_Asdu_t filler;
|
||
IEC104_TcpServerStatus_t status;
|
||
size_t length = IEC104_TCP_HIGH_CAPACITY - room - IEC104_ASDU_HIGH_ENTRY_HEADER_LEN;
|
||
CHECK(length >= 6U && length <= sizeof(bytes));
|
||
fake.send_blocked = 1U;
|
||
CHECK(IEC60870_Asdu_Create_From_Buffer(&filler,
|
||
IEC104_Slave_Get_Application_Layer_Parameters(command_slave), bytes, sizeof(bytes)) == IEC60870_ASDU_OK);
|
||
CHECK(IEC60870_MasterConnection_Send_ASDU(&command_last_input.connection, &filler));
|
||
CHECK(IEC60870_Asdu_Create_From_Buffer(&filler,
|
||
IEC104_Slave_Get_Application_Layer_Parameters(command_slave), bytes, length) == IEC60870_ASDU_OK);
|
||
CHECK(IEC60870_MasterConnection_Send_ASDU(&command_last_input.connection, &filler));
|
||
CHECK(IEC104_Slave_Get_Status(command_slave, &status, NULL) == IEC104_TCP_OK);
|
||
CHECK(status.asdu_queue_status_valid && status.high_queue.free_bytes == room);
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:在执行、有动作选择、纯逻辑选择三种模式下比较HIGH少1字节与刚好够用。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:预检WAIT不能调用动作,也不能消耗事件;恢复后同一事件可重试,但原决策期限不续期。
|
||
* confirm_room_waits只计准入等待,不应混入真正提交返回WAIT的waits。
|
||
*/
|
||
static void test_command_accept_capacity(void)
|
||
{
|
||
unsigned mode, short_room;
|
||
for (mode = 0U; mode < 3U; ++mode) {
|
||
for (short_room = 0U; short_room < 2U; ++short_room) {
|
||
IEC104_CommandConfig_t config;
|
||
IEC104_CommandEvent_t event;
|
||
IEC104_CommandTransactionInfo_t info;
|
||
command_config_default(&config);
|
||
if (mode == 0U) { command_config_mode(&config, IEC104_COMMAND_MODE_DIRECT); }
|
||
command_open(&config);
|
||
command_send(45U, 6U, 0x51U, 1U, 6001U, mode == 0U ? 1U : 0x81U);
|
||
event = command_take(mode == 0U ? IEC104_COMMAND_EXECUTE : IEC104_COMMAND_SELECT);
|
||
command_leave_high_room(12U - short_room);
|
||
CHECK(IEC104_Command_Accept(command, &event, mode == 2U ? NULL : command_action,
|
||
&command_action_calls) == (short_room ? IEC104_COMMAND_REPLY_WAIT : IEC104_COMMAND_REPLY_OK));
|
||
CHECK(IEC104_Command_Get_Status(command, &command_status));
|
||
CHECK(command_status.confirm_room_waits == short_room && command_status.waits == 0U);
|
||
CHECK(command_status.pending_replies == 0U);
|
||
CHECK(IEC104_Command_Get_Transaction(command, &event, &info));
|
||
CHECK(info.confirm_submitted == (short_room == 0U));
|
||
CHECK(command_action_calls == ((short_room == 0U && mode != 2U) ? 1U : 0U));
|
||
fake.send_blocked = 0U; command_poll(); command_flush();
|
||
if (short_room) {
|
||
CHECK(IEC104_Command_Accept(command, &event, mode == 2U ? NULL : command_action,
|
||
&command_action_calls) == IEC104_COMMAND_REPLY_OK);
|
||
CHECK(command_action_calls == (mode != 2U ? 1U : 0U));
|
||
}
|
||
command_flush();
|
||
command_reply_at(0U, 45U, 7U, 0x51U, 1U, 6001U, mode == 0U ? 1U : 0x81U);
|
||
CHECK(command_frame_count() == 1U);
|
||
command_close();
|
||
}
|
||
}
|
||
/* Capacity refusal does not postpone the decision timeout. Its negative
|
||
* reply is only arranged and may subsequently be dropped by cleanup. */
|
||
{
|
||
IEC104_CommandConfig_t config;
|
||
IEC104_CommandEvent_t event, finished;
|
||
command_config_default(&config); command_config_mode(&config, IEC104_COMMAND_MODE_DIRECT);
|
||
config.decision_timeout_ms = 10U; config.handover_timeout_ms = 10U;
|
||
command_open(&config); command_send(45U, 6U, 0x51U, 1U, 6001U, 1U);
|
||
event = command_take(IEC104_COMMAND_EXECUTE); command_congest();
|
||
CHECK(IEC104_Command_Accept(command, &event, command_action, &command_action_calls) == IEC104_COMMAND_REPLY_WAIT);
|
||
fake.now += 10U;
|
||
CHECK(IEC104_Command_Accept(command, &event, command_action, &command_action_calls) == IEC104_COMMAND_REPLY_STALE);
|
||
finished = command_take(IEC104_COMMAND_FINISHED);
|
||
CHECK(finished.reason == IEC104_COMMAND_FINISH_DECISION_TIMEOUT && !finished.execute_effect);
|
||
CHECK(command_action_calls == 0U);
|
||
fake.now += 10U; command_empty();
|
||
CHECK(IEC104_Command_Get_Status(command, &command_status));
|
||
CHECK(!command_status.busy && command_status.dropped_replies == 1U);
|
||
CHECK(command_status.confirm_room_waits == 1U && command_status.decision_timeouts == 1U);
|
||
CHECK(command_frame_count() == 0U);
|
||
command_close();
|
||
}
|
||
++command_checks;
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:即使HIGH已腾出空间,Accept也不代替Process发送本模块的旧回复,且必须先消费
|
||
* 新到达的Slave通知。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:其他点和不同OA同点的忙否定均须先于原执行确认,检查这两道门禁。
|
||
*/
|
||
static void test_command_accept_old_reply_gate(void)
|
||
{
|
||
IEC104_CommandConfig_t config;
|
||
IEC104_CommandEvent_t event;
|
||
uint8_t other[10];
|
||
command_config_default(&config); command_config_mode(&config, IEC104_COMMAND_MODE_DIRECT);
|
||
command_open(&config); command_send(45U, 6U, 0x51U, 1U, 6001U, 1U);
|
||
event = command_take(IEC104_COMMAND_EXECUTE); command_congest();
|
||
command_send(45U, 6U, 0x52U, 1U, 6002U, 1U);
|
||
CHECK(IEC104_Command_Get_Status(command, &command_status) && command_status.pending_replies == 1U);
|
||
fake.send_blocked = 0U; command_poll();
|
||
CHECK(IEC104_Command_Accept(command, &event, command_action, &command_action_calls) == IEC104_COMMAND_REPLY_WAIT);
|
||
CHECK(command_action_calls == 0U);
|
||
CHECK(IEC104_Command_Get_Status(command, &command_status));
|
||
CHECK(command_status.pending_replies == 1U && command_status.confirm_room_waits == 0U);
|
||
command_process(); command_poll();
|
||
command_bytes(other, 45U, 6U, 0x53U, 1U, 6001U, 1U);
|
||
command_queue(other, sizeof(other));
|
||
CHECK(IEC104_Slave_Poll(command_slave, 0U, NULL) == IEC104_TCP_OK);
|
||
CHECK(IEC104_Command_Accept(command, &event, command_action, &command_action_calls) == IEC104_COMMAND_REPLY_WAIT);
|
||
CHECK(command_action_calls == 0U);
|
||
command_drain_transport();
|
||
CHECK(IEC104_Command_Accept(command, &event, command_action, &command_action_calls) == IEC104_COMMAND_REPLY_OK);
|
||
command_flush();
|
||
command_reply_at(0U, 45U, 0x47U, 0x52U, 1U, 6002U, 1U);
|
||
command_reply_at(1U, 45U, 0x47U, 0x53U, 1U, 6001U, 1U);
|
||
command_reply_at(2U, 45U, 7U, 0x51U, 1U, 6001U, 1U);
|
||
CHECK(command_action_calls == 1U && command_frame_count() == 3U);
|
||
command_close(); ++command_checks;
|
||
}
|
||
|
||
#ifdef IEC104_COMMAND_TEST_HOOKS
|
||
/**
|
||
* 功能:验证以下场景与约束:服务查询失败和统计无效均终结为SERVICE_ERROR,动作次数为0。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:不能误计容量等待,也不能生成本来需要动作后才能发送的肯定确认。
|
||
*/
|
||
static void test_command_capacity_query_faults(void)
|
||
{
|
||
unsigned fault;
|
||
for (fault = 1U; fault <= 2U; ++fault) {
|
||
IEC104_CommandConfig_t config;
|
||
IEC104_CommandEvent_t event, finished;
|
||
command_config_default(&config); command_config_mode(&config, IEC104_COMMAND_MODE_DIRECT);
|
||
command_open(&config); command_send(45U, 6U, 0x51U, 1U, 6001U, 1U);
|
||
event = command_take(IEC104_COMMAND_EXECUTE);
|
||
command_capacity_fault = fault;
|
||
CHECK(IEC104_Command_Accept(command, &event, command_action, &command_action_calls) == IEC104_COMMAND_REPLY_ERROR);
|
||
finished = command_take(IEC104_COMMAND_FINISHED);
|
||
CHECK(finished.reason == IEC104_COMMAND_FINISH_SERVICE_ERROR && !finished.execute_effect);
|
||
CHECK(command_action_calls == 0U && command_frame_count() == 0U);
|
||
CHECK(IEC104_Command_Get_Status(command, &command_status));
|
||
CHECK(!command_status.active && !command_status.busy);
|
||
CHECK(command_status.confirm_room_waits == 0U && command_status.waits == 0U);
|
||
CHECK(command_status.cancelled == 1U && command_status.dropped_replies == 0U);
|
||
command_capacity_fault = 0U; command_close();
|
||
}
|
||
++command_checks;
|
||
}
|
||
#endif
|
||
|
||
/* ============================================================================
|
||
* [COMMAND/COMPLETION] 完成期限:Complete、交接超时、优先级与ENDED回收
|
||
* ============================================================================ */
|
||
/**
|
||
* 功能:验证以下场景与约束:设备结果已报告,但应用未及时Complete:恰到期限即结束,不补发ACT_TERM。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:重复Report_Result不得续期;已执行的effect标志仍为真,超时不代表设备动作回滚。
|
||
* 另验证禁用期限和时钟倒退,以及返校晚交付不能改写超时快照。
|
||
*/
|
||
static void test_command_complete_timeout(void)
|
||
{
|
||
unsigned mode;
|
||
for (mode = 0U; mode < 4U; ++mode) {
|
||
IEC104_CommandConfig_t config;
|
||
IEC104_CommandEvent_t event, finished;
|
||
uint64_t started;
|
||
command_config_default(&config); command_config_mode(&config, IEC104_COMMAND_MODE_DIRECT);
|
||
config.complete_timeout_ms = mode == 3U ? 0U : 10U;
|
||
command_open(&config); event = command_execute(45U, 1U); command_flush();
|
||
CHECK(IEC104_Command_Report_Result(command, &event, IEC104_COMMAND_RESULT_SUCCEEDED) == IEC104_COMMAND_REPLY_OK);
|
||
started = fake.now;
|
||
fake.now += 9U; command_empty();
|
||
CHECK(IEC104_Command_Get_Status(command, &command_status));
|
||
CHECK(command_status.timer_active == (mode != 3U));
|
||
CHECK(command_status.timeout_remaining_ms == (mode == 3U ? 0U : 1U));
|
||
CHECK(IEC104_Command_Report_Result(command, &event, IEC104_COMMAND_RESULT_FAILED) == IEC104_COMMAND_REPLY_ERROR);
|
||
if (mode == 3U) {
|
||
fake.now = started - 1U; command_empty();
|
||
CHECK(IEC104_Command_Get_Status(command, &command_status) && command_status.clock_errors == 0U);
|
||
fake.now = started + 100000U;
|
||
CHECK(IEC104_Command_Complete(command, &event) == IEC104_COMMAND_REPLY_OK);
|
||
command_flush(); finished = command_take(IEC104_COMMAND_FINISHED);
|
||
CHECK(finished.reason == IEC104_COMMAND_FINISH_COMPLETED);
|
||
CHECK(command_status.complete_timeouts == 0U);
|
||
} else {
|
||
fake.now = mode == 2U ? started - 1U : started + 10U + mode;
|
||
CHECK(IEC104_Command_Complete(command, &event) == IEC104_COMMAND_REPLY_STALE);
|
||
finished = command_take(IEC104_COMMAND_FINISHED);
|
||
CHECK(finished.reason == IEC104_COMMAND_FINISH_COMPLETE_TIMEOUT && finished.execute_effect);
|
||
CHECK(!finished.select_effect && !finished.return_info_undelivered);
|
||
CHECK(IEC104_Command_Get_Status(command, &command_status));
|
||
CHECK(command_status.complete_timeouts == 1U && command_status.handover_timeouts == 0U);
|
||
CHECK(command_status.clock_errors == (mode == 2U ? 1U : 0U));
|
||
CHECK(command_status.completed == 0U && command_status.execution_failed == 0U);
|
||
CHECK(command_status.execute_timeouts == 0U && command_status.dropped_replies == 0U);
|
||
CHECK(!command_status.busy && !command_status.timer_active);
|
||
CHECK(command_frame_count() == 1U);
|
||
}
|
||
command_close();
|
||
}
|
||
/* Complete timeout freezes an accepted but unhanded return too. Later
|
||
* delivery must not rewrite FINISHED or undo its conservative counter. */
|
||
{
|
||
IEC104_CommandConfig_t config;
|
||
IEC104_CommandEvent_t event, finished;
|
||
IEC60870_Asdu_t data;
|
||
uint8_t bytes[10];
|
||
command_config_default(&config); command_config_mode(&config, IEC104_COMMAND_MODE_DIRECT);
|
||
config.complete_timeout_ms = 10U;
|
||
command_window = 1U; command_open(&config);
|
||
event = command_execute(45U, 1U); command_flush();
|
||
CHECK(IEC104_Command_Report_Result(command, &event, IEC104_COMMAND_RESULT_SUCCEEDED) == IEC104_COMMAND_REPLY_OK);
|
||
command_return(&data, bytes, 1U, 1U);
|
||
CHECK(IEC104_Command_Submit_Return_Info(command, &event, &data) == IEC104_COMMAND_REPLY_OK);
|
||
fake.now += 10U;
|
||
finished = command_take(IEC104_COMMAND_FINISHED);
|
||
CHECK(finished.reason == IEC104_COMMAND_FINISH_COMPLETE_TIMEOUT && finished.return_info_undelivered);
|
||
CHECK(finished.execute_effect && !finished.select_effect);
|
||
push_ack(1U); command_poll(); command_flush();
|
||
command_reply_at(1U, 1U, 11U, 0x51U, 1U, 1001U, 1U);
|
||
CHECK(command_frame_count() == 2U && command_status.return_info_undelivered == 1U);
|
||
CHECK(command_status.complete_timeouts == 1U && command_status.completed == 0U);
|
||
CHECK(command_status.dropped_replies == 0U);
|
||
command_empty(); command_close();
|
||
}
|
||
++command_checks;
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:Complete之后等待交接超时:只可丢弃仍由模块保存的TERM。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:已交给HIGH的返校/TERM归传输层所有,可能在超时通知之后才发出;
|
||
* dropped_replies仅在本地TERM被清理时增加,不能把所有未HANDED帧都算丢弃。
|
||
*/
|
||
static void test_command_handover_timeout(void)
|
||
{
|
||
unsigned mode;
|
||
for (mode = 0U; mode < 4U; ++mode) {
|
||
IEC104_CommandConfig_t config;
|
||
IEC104_CommandEvent_t event, finished;
|
||
IEC60870_Asdu_t data;
|
||
uint8_t bytes[10];
|
||
uint64_t started;
|
||
command_config_default(&config); command_config_mode(&config, IEC104_COMMAND_MODE_DIRECT);
|
||
config.handover_timeout_ms = 10U;
|
||
if (mode != 0U) { command_window = 1U; }
|
||
command_open(&config); event = command_execute(45U, 1U); command_flush();
|
||
CHECK(IEC104_Command_Report_Result(command, &event, IEC104_COMMAND_RESULT_SUCCEEDED) == IEC104_COMMAND_REPLY_OK);
|
||
if (mode == 2U) {
|
||
command_return(&data, bytes, 1U, 1U);
|
||
CHECK(IEC104_Command_Submit_Return_Info(command, &event, &data) == IEC104_COMMAND_REPLY_OK);
|
||
}
|
||
if (mode == 0U) { command_congest(); }
|
||
CHECK(IEC104_Command_Complete(command, &event) == IEC104_COMMAND_REPLY_OK);
|
||
started = fake.now;
|
||
command_process(); command_empty();
|
||
fake.now += 9U; command_process();
|
||
CHECK(command_status.timeout_remaining_ms == 1U && command_status.timer_active);
|
||
CHECK(IEC104_Command_Complete(command, &event) == IEC104_COMMAND_REPLY_ERROR);
|
||
fake.now = mode == 3U ? started - 1U : started + 10U;
|
||
finished = command_take(IEC104_COMMAND_FINISHED);
|
||
CHECK(finished.reason == IEC104_COMMAND_FINISH_HANDOVER_TIMEOUT && finished.execute_effect);
|
||
CHECK(finished.return_info_undelivered == (mode == 2U));
|
||
CHECK(IEC104_Command_Get_Status(command, &command_status));
|
||
CHECK(command_status.handover_timeouts == 1U && command_status.complete_timeouts == 0U);
|
||
CHECK(command_status.completed == 0U && command_status.clock_errors == (mode == 3U ? 1U : 0U));
|
||
CHECK(command_status.dropped_replies == (mode == 0U ? 1U : 0U));
|
||
CHECK(!command_status.busy && !command_status.timer_active && command_status.pending_replies == 0U);
|
||
fake.now = started + 11U;
|
||
if (mode == 0U) { fake.send_blocked = 0U; command_flush(); CHECK(command_frame_count() == 1U); }
|
||
else {
|
||
push_ack(1U); command_poll(); command_flush();
|
||
if (mode == 2U) { push_ack(2U); command_poll(); command_flush(); }
|
||
CHECK(command_frame_count() == (mode == 2U ? 3U : 2U));
|
||
command_reply_at(mode == 2U ? 2U : 1U, 45U, 10U, 0x51U, 1U, 6001U, 1U);
|
||
}
|
||
CHECK(command_status.return_info_undelivered == (mode == 2U ? 1U : 0U));
|
||
command_empty(); command_close();
|
||
}
|
||
++command_checks;
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:本地待提交TERM也是事务尾部,不能因为当前凭证已交付就提前FINISHED。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:真正尾帧已HANDED后再推进时钟,多个入口均应优先识别正常完成/执行失败,
|
||
* 而不是因观察得晚误报交接超时。
|
||
*/
|
||
static void test_command_completion_precedence(void)
|
||
{
|
||
unsigned trigger;
|
||
for (trigger = 0U; trigger < 5U; ++trigger) {
|
||
IEC104_CommandConfig_t config;
|
||
IEC104_CommandEvent_t event, finished;
|
||
IEC60870_Asdu_t data;
|
||
uint8_t bytes[10];
|
||
command_config_default(&config); command_config_mode(&config, IEC104_COMMAND_MODE_DIRECT);
|
||
config.handover_timeout_ms = trigger == 0U ? 0U : 10U;
|
||
command_window = 1U; command_open(&config);
|
||
event = command_execute(45U, 1U); command_flush();
|
||
CHECK(IEC104_Command_Report_Result(command, &event,
|
||
trigger == 4U ? IEC104_COMMAND_RESULT_FAILED : IEC104_COMMAND_RESULT_SUCCEEDED) == IEC104_COMMAND_REPLY_OK);
|
||
CHECK(IEC104_Command_Complete(command, &event) == IEC104_COMMAND_REPLY_OK);
|
||
command_empty();
|
||
CHECK(IEC104_Command_Report_Result(command, &event, IEC104_COMMAND_RESULT_SUCCEEDED) == IEC104_COMMAND_REPLY_ERROR);
|
||
CHECK(IEC104_Command_Get_Status(command, &command_status));
|
||
CHECK(command_status.busy && command_status.pending_replies == 1U && command_status.completed == 0U);
|
||
command_process(); command_empty();
|
||
if (trigger == 0U) {
|
||
uint64_t previous = fake.now;
|
||
--fake.now; command_empty();
|
||
CHECK(IEC104_Command_Get_Status(command, &command_status));
|
||
CHECK(!command_status.timer_active && command_status.clock_errors == 0U);
|
||
fake.now = previous;
|
||
}
|
||
push_ack(1U); command_poll();
|
||
fake.now += 100U;
|
||
if (trigger == 1U) { CHECK(IEC104_Command_Complete(command, &event) == IEC104_COMMAND_REPLY_STALE); }
|
||
else if (trigger == 2U) {
|
||
CHECK(IEC104_Command_Report_Result(command, &event, IEC104_COMMAND_RESULT_SUCCEEDED) == IEC104_COMMAND_REPLY_STALE);
|
||
} else if (trigger == 3U) {
|
||
command_return(&data, bytes, 1U, 1U);
|
||
CHECK(IEC104_Command_Submit_Return_Info(command, &event, &data) == IEC104_COMMAND_REPLY_STALE);
|
||
}
|
||
finished = command_take(IEC104_COMMAND_FINISHED);
|
||
CHECK(finished.reason == (trigger == 4U ? IEC104_COMMAND_FINISH_EXECUTION_FAILED : IEC104_COMMAND_FINISH_COMPLETED));
|
||
CHECK(IEC104_Command_Get_Status(command, &command_status));
|
||
CHECK(command_status.completed == (trigger == 4U ? 0U : 1U));
|
||
CHECK(command_status.execution_failed == (trigger == 4U ? 1U : 0U) && command_status.handover_timeouts == 0U);
|
||
CHECK(command_status.dropped_replies == 0U && !command_status.busy);
|
||
command_close();
|
||
}
|
||
++command_checks;
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:拒绝已使事务进入ENDED,但本地否定回复仍可能堵在队列里。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:覆盖FINISHED已读/未读、另有回复、未读Slave通知、禁用期限和时钟倒退;
|
||
* 到期清理只回收本事务回复,不重复发FINISHED,也不清掉另一条独立回复。
|
||
*/
|
||
static void test_command_ended_cleanup(void)
|
||
{
|
||
unsigned mode;
|
||
for (mode = 0U; mode < 6U; ++mode) {
|
||
IEC104_CommandConfig_t config;
|
||
IEC104_CommandEvent_t event, finished;
|
||
uint64_t started;
|
||
uint8_t request[10];
|
||
command_config_default(&config); command_config_mode(&config, IEC104_COMMAND_MODE_DIRECT);
|
||
config.handover_timeout_ms = mode == 4U ? 0U : 10U;
|
||
command_open(&config); command_send(45U, 6U, 0x51U, 1U, 6001U, 1U);
|
||
event = command_take(IEC104_COMMAND_EXECUTE); command_congest();
|
||
CHECK(IEC104_Command_Reject(command, &event, IEC104_COMMAND_REJECT_NEGATIVE) == IEC104_COMMAND_REPLY_OK);
|
||
started = fake.now;
|
||
CHECK(IEC104_Command_Get_Status(command, &command_status));
|
||
CHECK(command_status.pending_replies == 1U && command_status.timer_active == (mode != 4U));
|
||
if (mode == 1U || mode == 2U || mode == 4U) {
|
||
finished = command_take(IEC104_COMMAND_FINISHED);
|
||
CHECK(finished.reason == IEC104_COMMAND_FINISH_REJECTED && !finished.execute_effect);
|
||
}
|
||
if (mode == 2U) {
|
||
command_send(45U, 6U, 0x52U, 1U, 6002U, 1U);
|
||
CHECK(IEC104_Command_Get_Status(command, &command_status) && command_status.pending_replies == 2U);
|
||
}
|
||
fake.now = started + 5U; command_process();
|
||
CHECK(command_status.timeout_remaining_ms == (mode == 4U ? 0U : 5U));
|
||
if (mode == 3U) {
|
||
command_bytes(request, 45U, 6U, 0x53U, 1U, 6001U, 1U);
|
||
command_queue(request, sizeof(request));
|
||
CHECK(IEC104_Slave_Poll(command_slave, 0U, NULL) == IEC104_TCP_OK);
|
||
CHECK(IEC104_Command_Get_Status(command, &command_status) && command_status.events_pending);
|
||
}
|
||
if (mode == 4U) {
|
||
fake.now = started - 1U; command_empty();
|
||
fake.now = started + 1000U; command_empty();
|
||
CHECK(IEC104_Command_Get_Status(command, &command_status));
|
||
CHECK(command_status.busy && command_status.pending_replies == 1U);
|
||
CHECK(command_status.dropped_replies == 0U && command_status.clock_errors == 0U);
|
||
fake.send_blocked = 0U; command_flush();
|
||
CHECK(!command_status.busy && !command_status.timer_active);
|
||
command_reply_at(0U, 45U, 0x47U, 0x51U, 1U, 6001U, 1U);
|
||
} else {
|
||
fake.now = mode == 5U ? started - 1U : started + 10U;
|
||
if (mode == 0U || mode == 3U || mode == 5U) {
|
||
finished = command_take(IEC104_COMMAND_FINISHED);
|
||
CHECK(finished.reason == IEC104_COMMAND_FINISH_REJECTED && !finished.execute_effect);
|
||
} else { command_empty(); }
|
||
CHECK(IEC104_Command_Get_Status(command, &command_status));
|
||
CHECK(!command_status.busy && !command_status.timer_active);
|
||
CHECK(command_status.pending_replies == (mode == 2U ? 1U : 0U));
|
||
CHECK(command_status.dropped_replies == 1U && command_status.app_rejected == 1U);
|
||
CHECK(command_status.clock_errors == (mode == 5U ? 1U : 0U));
|
||
CHECK(command_status.handover_timeouts == 0U && command_status.complete_timeouts == 0U);
|
||
CHECK(command_status.dropped_requests == 0U);
|
||
if (mode == 0U || mode == 1U || mode == 5U) { CHECK(!command_status.need_process); }
|
||
if (mode == 2U) {
|
||
fake.send_blocked = 0U; command_flush();
|
||
command_reply_at(0U, 45U, 0x47U, 0x52U, 1U, 6002U, 1U);
|
||
CHECK(command_frame_count() == 1U && command_status.pending_replies == 0U);
|
||
}
|
||
}
|
||
fake.now = started + 1001U;
|
||
command_close();
|
||
}
|
||
/* An unread FINISHED alone must not keep the expired timer alive. */
|
||
{
|
||
IEC104_CommandConfig_t config;
|
||
IEC104_CommandEvent_t event;
|
||
command_config_default(&config); command_config_mode(&config, IEC104_COMMAND_MODE_DIRECT);
|
||
config.handover_timeout_ms = 10U;
|
||
command_open(&config); command_send(45U, 6U, 0x51U, 1U, 6001U, 1U);
|
||
event = command_take(IEC104_COMMAND_EXECUTE);
|
||
CHECK(IEC104_Command_Reject(command, &event, IEC104_COMMAND_REJECT_NEGATIVE) == IEC104_COMMAND_REPLY_OK);
|
||
command_flush(); fake.now += 100U;
|
||
CHECK(IEC104_Command_Get_Status(command, &command_status));
|
||
CHECK(command_status.busy && command_status.pending_events == 1U);
|
||
CHECK(command_status.pending_replies == 0U && !command_status.timer_active && !command_status.need_process);
|
||
CHECK(command_take(IEC104_COMMAND_FINISHED).reason == IEC104_COMMAND_FINISH_REJECTED);
|
||
command_close();
|
||
}
|
||
++command_checks;
|
||
}
|
||
|
||
/* ============================================================================
|
||
* [COMMAND/ACTION_TIME] 动作前时效:等待中过期、拒绝原因及凭证故障
|
||
* ============================================================================ */
|
||
/**
|
||
* 功能:验证以下场景与约束:带时标请求受理时有效不代表动作时仍有效。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:选择/执行、是否否定应答、是否先遇
|
||
* 容量WAIT做交叉组合。过期后重试必须STALE且动作次数为0,计入动作前时效计数,
|
||
* 不计成请求到达时的拒绝或设备执行超时。
|
||
*/
|
||
static void test_command_action_time_expiry(void)
|
||
{
|
||
unsigned selecting, negative, capacity_wait;
|
||
for (selecting = 0U; selecting < 2U; ++selecting) {
|
||
for (negative = 0U; negative < 2U; ++negative) {
|
||
for (capacity_wait = 0U; capacity_wait < 2U; ++capacity_wait) {
|
||
IEC104_CommandConfig_t config;
|
||
IEC104_CommandEvent_t event, finished;
|
||
uint8_t bytes[32], payload = selecting ? 0x81U : 1U;
|
||
size_t length;
|
||
command_timed_config(&config, 58U, 10U);
|
||
if (selecting) { command_config_mode(&config, IEC104_COMMAND_MODE_SELECT_EXECUTE); }
|
||
config.negative_on_expired = negative != 0U;
|
||
command_open(&config);
|
||
CHECK(IEC104_Command_Set_Time_Base(command, command_epoch_ms, fake.now));
|
||
length = command_timed_bytes(bytes, 58U, 6U, 0x51U, 1U, 6001U,
|
||
&payload, 1U, command_epoch_time);
|
||
command_raw_send(bytes, length);
|
||
event = command_take(selecting ? IEC104_COMMAND_SELECT : IEC104_COMMAND_EXECUTE);
|
||
if (capacity_wait) {
|
||
command_congest();
|
||
CHECK(IEC104_Command_Accept(command, &event, command_action, &command_action_calls) == IEC104_COMMAND_REPLY_WAIT);
|
||
}
|
||
fake.now += 10U;
|
||
CHECK(IEC104_Command_Accept(command, &event, command_action, &command_action_calls) == IEC104_COMMAND_REPLY_STALE);
|
||
CHECK(command_action_calls == 0U);
|
||
finished = command_take(IEC104_COMMAND_FINISHED);
|
||
CHECK(finished.reason == IEC104_COMMAND_FINISH_TIME_EXPIRED);
|
||
CHECK(!finished.select_effect && !finished.execute_effect && !finished.return_info_undelivered);
|
||
CHECK(finished.request.time_utc_ms == command_epoch_ms);
|
||
fake.send_blocked = 0U; command_flush();
|
||
CHECK(command_status.action_time_expired == 1U && command_status.action_time_rejected == 0U);
|
||
CHECK(command_status.time_expired == 0U && command_status.time_rejected == 0U);
|
||
CHECK(command_status.rejected == 0U && command_status.dropped_requests == 0U);
|
||
CHECK(command_status.completed == 0U && command_status.confirm_room_waits == capacity_wait);
|
||
CHECK(command_status.negative_submitted == negative && command_frame_count() == negative);
|
||
if (negative) { command_raw_reply_at(0U, bytes, length, 0x71U); }
|
||
CHECK(!command_status.busy);
|
||
command_close();
|
||
}
|
||
}
|
||
}
|
||
++command_checks;
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:使用真实默认10s时标窗/15s决定期限、UTC+8及过期否定策略,不覆盖回复配置。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:初始年龄0/2s分别只剩10/8s:边界前1ms仍可接受,恰好到界必须拒绝。
|
||
* Status报告阶段期限,Process不因时标到界自动终结;Accept仍须独立复查。
|
||
* 核对否定原文、唯一FINISHED及重复Accept,防止把查询余量误当成执行许可。
|
||
*/
|
||
static void test_command_default_time_window(void)
|
||
{
|
||
static const uint8_t local_time[7] = {0U, 0U, 0U, 8U, 1U, 1U, 26U};
|
||
unsigned selecting, aged, expired;
|
||
for (selecting = 0U; selecting < 2U; ++selecting) {
|
||
for (aged = 0U; aged < 2U; ++aged) {
|
||
for (expired = 0U; expired < 2U; ++expired) {
|
||
IEC104_CommandConfig_t config;
|
||
IEC104_CommandEvent_t event, finished;
|
||
uint8_t bytes[32], payload = selecting ? 0x81U : 1U;
|
||
uint32_t age = aged ? 2000U : 0U;
|
||
uint32_t waited = 10000U - age - (expired ? 0U : 1U);
|
||
size_t length;
|
||
command_config_default(&config);
|
||
CHECK(config.time_tag_max_delay_ms == 10000U && config.decision_timeout_ms == 15000U);
|
||
CHECK(config.master_utc_offset_minutes == 480 && config.negative_on_expired);
|
||
command_config_mode(&config, selecting ? IEC104_COMMAND_MODE_SELECT_EXECUTE :
|
||
IEC104_COMMAND_MODE_DIRECT);
|
||
command_open(&config);
|
||
CHECK(IEC104_Command_Set_Time_Base(command, command_epoch_ms + age, fake.now));
|
||
length = command_timed_bytes(bytes, 58U, 6U, 0x51U, 1U, 6001U,
|
||
&payload, 1U, local_time);
|
||
command_raw_send(bytes, length);
|
||
event = command_take(selecting ? IEC104_COMMAND_SELECT : IEC104_COMMAND_EXECUTE);
|
||
CHECK(event.request.time_utc_ms == command_epoch_ms);
|
||
fake.now += waited;
|
||
command_process();
|
||
CHECK(command_status.busy && command_status.timer_active && !command_status.need_process);
|
||
CHECK(command_status.timeout_remaining_ms == 15000U - waited);
|
||
CHECK(command_status.action_time_expired == 0U && command_status.decision_timeouts == 0U);
|
||
if (expired) {
|
||
CHECK(IEC104_Command_Accept(command, &event, command_action,
|
||
&command_action_calls) == IEC104_COMMAND_REPLY_STALE);
|
||
CHECK(IEC104_Command_Accept(command, &event, command_action,
|
||
&command_action_calls) == IEC104_COMMAND_REPLY_STALE);
|
||
CHECK(command_action_calls == 0U);
|
||
finished = command_take(IEC104_COMMAND_FINISHED);
|
||
CHECK(finished.reason == IEC104_COMMAND_FINISH_TIME_EXPIRED);
|
||
CHECK(!finished.select_effect && !finished.execute_effect && !finished.return_info_undelivered);
|
||
CHECK(finished.transaction_id == event.transaction_id &&
|
||
finished.request.time_utc_ms == command_epoch_ms);
|
||
command_flush();
|
||
command_empty();
|
||
CHECK(IEC104_Command_Accept(command, &event, command_action,
|
||
&command_action_calls) == IEC104_COMMAND_REPLY_STALE);
|
||
command_process();
|
||
CHECK(command_action_calls == 0U && command_frame_count() == 1U);
|
||
command_raw_reply_at(0U, bytes, length, 0x71U);
|
||
CHECK(command_status.action_time_expired == 1U && command_status.action_time_rejected == 0U);
|
||
CHECK(command_status.time_expired == 0U && command_status.time_rejected == 0U);
|
||
CHECK(command_status.decision_timeouts == 0U && command_status.negative_submitted == 1U);
|
||
CHECK(!command_status.busy && !command_status.timer_active && !command_status.need_process);
|
||
CHECK(command_status.pending_events == 0U && command_status.pending_replies == 0U);
|
||
} else {
|
||
CHECK(IEC104_Command_Accept(command, &event, command_action,
|
||
&command_action_calls) == IEC104_COMMAND_REPLY_OK);
|
||
CHECK(IEC104_Command_Accept(command, &event, command_action,
|
||
&command_action_calls) == IEC104_COMMAND_REPLY_STALE);
|
||
command_flush();
|
||
CHECK(command_action_calls == 1U && command_frame_count() == 1U);
|
||
command_raw_reply_at(0U, bytes, length, 7U);
|
||
CHECK(command_status.action_time_expired == 0U && command_status.negative_submitted == 0U);
|
||
if (!selecting) { (void)command_done(&event, IEC104_COMMAND_RESULT_SUCCEEDED); }
|
||
}
|
||
command_close();
|
||
}
|
||
}
|
||
}
|
||
++command_checks;
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:受理后清除/改变UTC基准仍须重新验证动作时效。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:单调决策时钟倒退另归决策超时。
|
||
* 模式5显式禁用时效检查,模式6由应用主动拒绝;二者不能误计为时基拒绝。
|
||
* 后半段还验证:旧回复门禁解除后,才对将要执行的动作检查已经过期的时标。
|
||
*/
|
||
static void test_command_action_time_rejections(void)
|
||
{
|
||
unsigned mode;
|
||
for (mode = 0U; mode < 7U; ++mode) {
|
||
IEC104_CommandConfig_t config;
|
||
IEC104_CommandEvent_t event, finished;
|
||
uint8_t bytes[32], payload = 1U;
|
||
size_t length;
|
||
uint64_t started;
|
||
const uint64_t maximum = (uint64_t)IEC60870_TIME_MAX_SECONDS * 1000U + 999U;
|
||
command_timed_config(&config, 58U, mode == 5U ? 0U : 100U);
|
||
command_open(&config);
|
||
CHECK(IEC104_Command_Set_Time_Base(command, command_epoch_ms, fake.now));
|
||
length = command_timed_bytes(bytes, 58U, 6U, 0x51U, 1U, 6001U,
|
||
&payload, 1U, command_epoch_time);
|
||
command_raw_send(bytes, length); event = command_take(IEC104_COMMAND_EXECUTE);
|
||
started = fake.now;
|
||
switch (mode) {
|
||
case 1U:
|
||
fake.now += 2U;
|
||
CHECK(IEC104_Command_Set_Time_Base(command, command_epoch_ms + 2U, fake.now));
|
||
--fake.now;
|
||
break;
|
||
case 2U:
|
||
CHECK(IEC104_Command_Set_Time_Base(command, maximum, fake.now));
|
||
++fake.now;
|
||
break;
|
||
case 3U: CHECK(IEC104_Command_Set_Time_Base(command, command_epoch_ms - 100U, fake.now)); break;
|
||
case 4U: --fake.now; break;
|
||
default: IEC104_Command_Clear_Time_Base(command); break;
|
||
}
|
||
if (mode == 5U) {
|
||
CHECK(IEC104_Command_Accept(command, &event, command_action, &command_action_calls) == IEC104_COMMAND_REPLY_OK);
|
||
CHECK(command_action_calls == 1U);
|
||
finished = command_done(&event, IEC104_COMMAND_RESULT_SUCCEEDED);
|
||
CHECK(finished.reason == IEC104_COMMAND_FINISH_COMPLETED);
|
||
} else if (mode == 6U) {
|
||
CHECK(IEC104_Command_Reject(command, &event, IEC104_COMMAND_REJECT_NEGATIVE) == IEC104_COMMAND_REPLY_OK);
|
||
command_flush(); finished = command_take(IEC104_COMMAND_FINISHED);
|
||
CHECK(finished.reason == IEC104_COMMAND_FINISH_REJECTED && command_action_calls == 0U);
|
||
} else {
|
||
CHECK(IEC104_Command_Accept(command, &event, command_action, &command_action_calls) == IEC104_COMMAND_REPLY_STALE);
|
||
finished = command_take(IEC104_COMMAND_FINISHED);
|
||
CHECK(finished.reason == (mode == 4U ? IEC104_COMMAND_FINISH_DECISION_TIMEOUT : IEC104_COMMAND_FINISH_TIME_REJECTED));
|
||
CHECK(command_action_calls == 0U && !finished.execute_effect);
|
||
}
|
||
fake.now = started + 10U; command_flush();
|
||
CHECK(command_status.action_time_rejected == (mode < 4U ? 1U : 0U));
|
||
CHECK(command_status.action_time_expired == 0U && command_status.time_rejected == 0U && command_status.time_expired == 0U);
|
||
CHECK(command_status.clock_errors == (mode == 1U || mode == 4U ? 1U : 0U));
|
||
CHECK(command_status.decision_timeouts == (mode == 4U ? 1U : 0U));
|
||
if (mode < 4U || mode == 6U) { command_raw_reply_at(0U, bytes, length, mode < 4U ? 0x71U : 0x47U); }
|
||
command_close();
|
||
}
|
||
/* A pending old reply gates before the time guard. Freshness is checked
|
||
* as soon as that predecessor has been submitted, not on blocked retries. */
|
||
{
|
||
IEC104_CommandConfig_t config;
|
||
IEC104_CommandEvent_t event;
|
||
uint8_t bytes[32], payload = 1U;
|
||
size_t length;
|
||
command_timed_config(&config, 58U, 10U); command_open(&config);
|
||
CHECK(IEC104_Command_Set_Time_Base(command, command_epoch_ms, fake.now));
|
||
length = command_timed_bytes(bytes, 58U, 6U, 0x51U, 1U, 6001U,
|
||
&payload, 1U, command_epoch_time);
|
||
command_raw_send(bytes, length); event = command_take(IEC104_COMMAND_EXECUTE); command_congest();
|
||
++bytes[6]; bytes[3] = 0x52U;
|
||
command_raw_send(bytes, length);
|
||
fake.now += 10U;
|
||
CHECK(IEC104_Command_Accept(command, &event, command_action, &command_action_calls) == IEC104_COMMAND_REPLY_WAIT);
|
||
CHECK(IEC104_Command_Get_Status(command, &command_status));
|
||
CHECK(command_status.action_time_expired == 0U && command_status.confirm_room_waits == 0U);
|
||
fake.send_blocked = 0U; command_flush();
|
||
CHECK(IEC104_Command_Accept(command, &event, command_action, &command_action_calls) == IEC104_COMMAND_REPLY_STALE);
|
||
CHECK(command_take(IEC104_COMMAND_FINISHED).reason == IEC104_COMMAND_FINISH_TIME_EXPIRED);
|
||
CHECK(command_action_calls == 0U); command_close();
|
||
}
|
||
++command_checks;
|
||
}
|
||
|
||
#ifdef IEC104_COMMAND_TEST_HOOKS
|
||
/**
|
||
* 功能:验证以下场景与约束:强制尾部凭证查询失败,覆盖请求分派、结果报告、返校提交和NextEvent入口。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:都须以SERVICE_ERROR结束已执行事务并保留execute_effect;新到达请求不得被
|
||
* 接受或额外生成回复,避免查询故障被当作旧事务已正常交付。
|
||
*/
|
||
static void test_command_response_ticket_faults(void)
|
||
{
|
||
unsigned entry;
|
||
for (entry = 0U; entry < 4U; ++entry) {
|
||
IEC104_CommandConfig_t config;
|
||
IEC104_CommandEvent_t event, finished;
|
||
IEC60870_Asdu_t data;
|
||
uint8_t bytes[10];
|
||
command_config_default(&config); command_config_mode(&config, IEC104_COMMAND_MODE_DIRECT);
|
||
config.handover_timeout_ms = 0U;
|
||
command_window = 1U; command_open(&config);
|
||
event = command_execute(45U, 1U); command_flush();
|
||
CHECK(IEC104_Command_Report_Result(command, &event, IEC104_COMMAND_RESULT_SUCCEEDED) == IEC104_COMMAND_REPLY_OK);
|
||
CHECK(IEC104_Command_Complete(command, &event) == IEC104_COMMAND_REPLY_OK);
|
||
command_process(); command_empty();
|
||
command_response_error = true;
|
||
if (entry == 0U) {
|
||
IEC104_SlaveEvent_t input;
|
||
IEC104_TcpEventResult_t next;
|
||
unsigned seen = 0U;
|
||
command_bytes(bytes, 45U, 6U, 0x52U, 1U, 6002U, 1U);
|
||
command_queue(bytes, sizeof(bytes));
|
||
CHECK(IEC104_Slave_Poll(command_slave, 0U, NULL) == IEC104_TCP_OK);
|
||
while ((next = IEC104_Slave_NextEvent(command_slave, &input)) == IEC104_TCP_EVENT_READY) {
|
||
IEC104_CommandEventResult_t handled = IEC104_Command_Handle_Event(command, &input);
|
||
if (input.transport.type == IEC104_TCP_EVENT_I_FRAME) {
|
||
CHECK(handled == IEC104_COMMAND_EVENT_ERROR); ++seen;
|
||
} else { CHECK(handled != IEC104_COMMAND_EVENT_ERROR); }
|
||
}
|
||
CHECK(next == IEC104_TCP_EVENT_EMPTY && seen == 1U);
|
||
} else if (entry == 1U) {
|
||
CHECK(IEC104_Command_Report_Result(command, &event, IEC104_COMMAND_RESULT_SUCCEEDED) == IEC104_COMMAND_REPLY_ERROR);
|
||
} else if (entry == 2U) {
|
||
command_return(&data, bytes, 1U, 1U);
|
||
CHECK(IEC104_Command_Submit_Return_Info(command, &event, &data) == IEC104_COMMAND_REPLY_ERROR);
|
||
}
|
||
finished = command_take(IEC104_COMMAND_FINISHED);
|
||
CHECK(finished.reason == IEC104_COMMAND_FINISH_SERVICE_ERROR && finished.execute_effect);
|
||
CHECK(IEC104_Command_Get_Status(command, &command_status));
|
||
CHECK(!command_status.active && !command_status.busy);
|
||
CHECK(command_status.accepted == 1U && command_status.submitted == 2U);
|
||
CHECK(command_status.pending_replies == 0U && command_status.rejected == 0U);
|
||
CHECK(command_status.cancelled == 1U && command_status.handover_timeouts == 0U);
|
||
CHECK(command_action_calls == 1U && command_frame_count() == 1U);
|
||
command_response_error = false;
|
||
command_empty(); command_close();
|
||
}
|
||
++command_checks;
|
||
}
|
||
#endif
|
||
|
||
/* ============================================================================
|
||
* [COMMAND/ABNORMAL] 异常收尾:失败/超时否定TERM、期限及会话边界
|
||
* ============================================================================ */
|
||
/**
|
||
* 功能:验证以下场景与约束:NOT_STARTED/动作FAILED没有进入已启动流程,仍只回否定ACT_CON。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:固定失败TERM规则不能把拒绝启动改写为执行后终止,也不能重做设备动作。
|
||
*/
|
||
static void test_command_action_failure_boundary(void)
|
||
{
|
||
unsigned outcome;
|
||
for (outcome = 0U; outcome < 2U; ++outcome) {
|
||
IEC104_CommandConfig_t config;
|
||
IEC104_CommandEvent_t event, finished;
|
||
command_config_default(&config); command_config_mode(&config, IEC104_COMMAND_MODE_DIRECT);
|
||
command_open(&config);
|
||
command_action_result = outcome ? IEC104_COMMAND_ACTION_FAILED : IEC104_COMMAND_ACTION_NOT_STARTED;
|
||
event = command_execute(45U, 1U); command_flush();
|
||
finished = command_take(IEC104_COMMAND_FINISHED);
|
||
CHECK(finished.reason == (outcome ? IEC104_COMMAND_FINISH_ACTION_FAILED : IEC104_COMMAND_FINISH_REJECTED));
|
||
CHECK(finished.execute_effect == (outcome != 0U) && command_action_calls == 1U);
|
||
CHECK(IEC104_Command_Report_Result(command, &event, IEC104_COMMAND_RESULT_FAILED) == IEC104_COMMAND_REPLY_STALE);
|
||
CHECK(IEC104_Command_Complete(command, &event) == IEC104_COMMAND_REPLY_STALE);
|
||
CHECK(command_frame_count() == 1U);
|
||
command_reply_at(0U, 45U, 0x47U, 0x51U, 1U, 6001U, 1U);
|
||
command_empty(); command_close();
|
||
}
|
||
++command_checks;
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:明确失败的TERM与成功路径共用HIGH/FIFO:确认、返回信息、旧忙回复、否定TERM。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:满HIGH时不重做动作,不空转,也不提前交付已知结果的FINISHED。
|
||
* negative_submitted最终为2:一条是新命令的忙否定ACT_CON,一条是原事务的失败TERM。
|
||
*/
|
||
static void test_command_negative_term_wait(void)
|
||
{
|
||
IEC104_CommandConfig_t config;
|
||
IEC104_CommandEvent_t event, finished;
|
||
IEC60870_Asdu_t data;
|
||
uint8_t bytes[10];
|
||
command_config_default(&config); command_config_mode(&config, IEC104_COMMAND_MODE_DIRECT);
|
||
command_open(&config); event = command_execute(45U, 1U); command_flush();
|
||
command_return(&data, bytes, 1U, 1U);
|
||
CHECK(IEC104_Command_Submit_Return_Info(command, &event, &data) == IEC104_COMMAND_REPLY_OK);
|
||
command_flush(); command_leave_high_room(0U);
|
||
command_send(45U, 6U, 0x52U, 1U, 6002U, 1U);
|
||
CHECK(IEC104_Command_Report_Result(command, &event, IEC104_COMMAND_RESULT_FAILED) == IEC104_COMMAND_REPLY_OK);
|
||
CHECK(IEC104_Command_Complete(command, &event) == IEC104_COMMAND_REPLY_OK);
|
||
command_process(); command_empty();
|
||
CHECK(command_status.pending_replies == 2U && !command_status.need_process);
|
||
CHECK(command_status.busy && command_status.execution_failed == 0U);
|
||
CHECK(command_frame_count() == 2U && command_action_calls == 1U);
|
||
CHECK(IEC104_Command_Complete(command, &event) == IEC104_COMMAND_REPLY_ERROR);
|
||
fake.send_blocked = 0U; command_flush();
|
||
CHECK(command_frame_count() == 4U);
|
||
command_reply_at(0U, 45U, 7U, 0x51U, 1U, 6001U, 1U);
|
||
command_reply_at(1U, 1U, 11U, 0x51U, 1U, 1001U, 1U);
|
||
command_reply_at(2U, 45U, 0x47U, 0x52U, 1U, 6002U, 1U);
|
||
command_reply_at(3U, 45U, 0x4aU, 0x51U, 1U, 6001U, 1U);
|
||
finished = command_take(IEC104_COMMAND_FINISHED);
|
||
CHECK(finished.reason == IEC104_COMMAND_FINISH_EXECUTION_FAILED && finished.execute_effect);
|
||
CHECK(command_status.negative_submitted == 2U && command_status.return_info_submitted == 1U);
|
||
CHECK(command_action_calls == 1U);
|
||
command_empty(); command_close(); ++command_checks;
|
||
}
|
||
|
||
/**
|
||
* 功能:所有会推进期限的公开入口必须执行相同超时转换。
|
||
* 输入参数:entry——公开入口选择号;event——业务或传输事件(只读);finished——终结事件存储。
|
||
* 输出参数:finished——NextEvent 分支取出的 FINISHED 事件。
|
||
* 返回值:true 表示 NextEvent 分支已取走 FINISHED;false 表示由调用方继续读取终结事件。
|
||
* 说明:entry依次覆盖Process、NextEvent、Report_Result、Complete、Submit_Return_Info和I帧Handle_Event。
|
||
* 返回true只表示NextEvent已取走FINISHED,其余入口由调用方统一读取,避免误测成重复通知。
|
||
* 新I帧触发到期后,原槽仍欠FINISHED/TERM,新的命令只能获得忙否定而不能执行。
|
||
*/
|
||
static bool command_timeout_entry(unsigned entry, const IEC104_CommandEvent_t *event,
|
||
IEC104_CommandEvent_t *finished)
|
||
{
|
||
IEC60870_Asdu_t data;
|
||
uint8_t bytes[10];
|
||
if (entry == 0U) { CHECK(IEC104_Command_Process(command)); }
|
||
else if (entry == 1U) {
|
||
CHECK(IEC104_Command_NextEvent(command, finished) == IEC104_COMMAND_NEXT_READY);
|
||
return true;
|
||
} else if (entry == 2U) {
|
||
CHECK(IEC104_Command_Report_Result(command, event, IEC104_COMMAND_RESULT_SUCCEEDED) == IEC104_COMMAND_REPLY_STALE);
|
||
} else if (entry == 3U) { CHECK(IEC104_Command_Complete(command, event) == IEC104_COMMAND_REPLY_STALE); }
|
||
else if (entry == 4U) {
|
||
command_return(&data, bytes, 1U, 1U);
|
||
CHECK(IEC104_Command_Submit_Return_Info(command, event, &data) == IEC104_COMMAND_REPLY_STALE);
|
||
} else {
|
||
command_send(45U, 6U, 0x52U, 1U, 6002U, 1U);
|
||
CHECK(command_last_handled == IEC104_COMMAND_EVENT_HANDLED);
|
||
}
|
||
return false;
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:9ms未到期,10ms固定产生否定TERM,但结果仍未知。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:先读FINISHED再解堵,
|
||
* 检查ENDED事务仍保存TERM、连接保持激活,迟到结果不能覆盖原因或重复动作。
|
||
* info.active=false表示应用事务结束,status.active=true表示会话仍激活;两者不矛盾。
|
||
* 未知结果只计execute_timeouts,不计completed/execution_failed;背压解除前也不计negative_submitted。
|
||
*/
|
||
static void test_command_timeout_term_entries(void)
|
||
{
|
||
unsigned entry;
|
||
for (entry = 0U; entry < 6U; ++entry) {
|
||
IEC104_CommandConfig_t config;
|
||
IEC104_CommandEvent_t event, finished, next_event;
|
||
IEC104_CommandTransactionInfo_t info;
|
||
IEC104_TcpServerStatus_t transport;
|
||
IEC60870_Asdu_t data;
|
||
uint8_t bytes[10];
|
||
command_config_default(&config); command_config_mode(&config, IEC104_COMMAND_MODE_DIRECT);
|
||
config.execute_timeout_ms = 10U;
|
||
command_open(&config); event = command_execute(45U, 1U); command_flush();
|
||
command_leave_high_room(0U);
|
||
fake.now += 9U; command_process(); command_empty();
|
||
CHECK(command_status.timeout_remaining_ms == 1U && command_status.active);
|
||
++fake.now;
|
||
if (!command_timeout_entry(entry, &event, &finished)) { finished = command_take(IEC104_COMMAND_FINISHED); }
|
||
CHECK(finished.type == IEC104_COMMAND_FINISHED);
|
||
CHECK(finished.reason == IEC104_COMMAND_FINISH_EXECUTE_TIMEOUT && finished.execute_effect);
|
||
CHECK(finished.transaction_id == event.transaction_id && !finished.select_effect);
|
||
CHECK(IEC104_Command_Get_Transaction(command, &event, &info));
|
||
CHECK(!info.active && info.phase == IEC104_COMMAND_PHASE_ENDED);
|
||
CHECK(!info.result_reported && !info.completed && !info.term_submitted);
|
||
command_process(); command_empty();
|
||
CHECK(command_status.active && command_status.busy && !command_status.need_process);
|
||
CHECK(command_status.accepted == 1U && command_status.execute_timeouts == 1U);
|
||
CHECK(command_status.completed == 0U && command_status.execution_failed == 0U);
|
||
CHECK(command_status.pending_replies == (entry == 5U ? 2U : 1U) && command_status.pending_events == 0U);
|
||
CHECK(command_status.negative_submitted == 0U && command_action_calls == 1U);
|
||
CHECK(IEC104_Slave_Get_Status(command_slave, &transport, NULL) == IEC104_TCP_OK);
|
||
CHECK(transport.listening && transport.connected && transport.generation == event.request.generation);
|
||
CHECK(IEC104_Command_Report_Result(command, &event, IEC104_COMMAND_RESULT_FAILED) == IEC104_COMMAND_REPLY_STALE);
|
||
CHECK(IEC104_Command_Complete(command, &event) == IEC104_COMMAND_REPLY_STALE);
|
||
command_return(&data, bytes, 1U, 1U);
|
||
CHECK(IEC104_Command_Submit_Return_Info(command, &event, &data) == IEC104_COMMAND_REPLY_STALE);
|
||
CHECK(command_frame_count() == 1U);
|
||
fake.send_blocked = 0U; command_flush(); command_empty();
|
||
CHECK(command_frame_count() == (entry == 5U ? 3U : 2U));
|
||
command_reply_at(0U, 45U, 7U, 0x51U, 1U, 6001U, 1U);
|
||
command_reply_at(1U, 45U, 0x4aU, 0x51U, 1U, 6001U, 1U);
|
||
if (entry == 5U) { command_reply_at(2U, 45U, 0x47U, 0x52U, 1U, 6002U, 1U); }
|
||
CHECK(!command_status.busy && !command_status.timer_active && !command_status.need_process);
|
||
CHECK(command_status.active && command_status.execute_timeouts == 1U);
|
||
next_event = command_execute(45U, 1U);
|
||
CHECK(next_event.request.generation == event.request.generation);
|
||
(void)command_done(&next_event, IEC104_COMMAND_RESULT_SUCCEEDED);
|
||
CHECK(command_action_calls == 2U && command_status.execute_timeouts == 1U);
|
||
command_close();
|
||
}
|
||
++command_checks;
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:STOP/断线通知先于到期处理:不能给已停止的会话另造TERM。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:重新连接后旧事件仍STALE,新命令不受旧超时期限或返回结果影响。
|
||
*/
|
||
static void test_command_timeout_term_lifetime(void)
|
||
{
|
||
unsigned stop;
|
||
for (stop = 0U; stop < 2U; ++stop) {
|
||
IEC104_CommandConfig_t config;
|
||
IEC104_CommandEvent_t event, finished, next_event;
|
||
command_config_default(&config); command_config_mode(&config, IEC104_COMMAND_MODE_DIRECT);
|
||
config.execute_timeout_ms = 10U;
|
||
command_open(&config); event = command_execute(45U, 1U); command_flush();
|
||
fake.now += 10U;
|
||
if (stop) { push(stop_act, sizeof(stop_act)); }
|
||
else { fake.recv_eof = 1U; }
|
||
CHECK(IEC104_Slave_Poll(command_slave, 0U, NULL) == IEC104_TCP_OK);
|
||
CHECK(IEC104_Command_Report_Result(command, &event, IEC104_COMMAND_RESULT_SUCCEEDED) == IEC104_COMMAND_REPLY_WAIT);
|
||
command_drain_transport(); fake.recv_eof = 0U;
|
||
finished = command_take(IEC104_COMMAND_FINISHED);
|
||
CHECK(finished.reason == (stop ? IEC104_COMMAND_FINISH_STOPPED : IEC104_COMMAND_FINISH_DISCONNECTED));
|
||
CHECK(finished.execute_effect && command_frame_count() == 1U);
|
||
CHECK(IEC104_Command_Get_Status(command, &command_status));
|
||
CHECK(command_status.execute_timeouts == 0U && !command_status.active);
|
||
if (stop) { fake.recv_eof = 1U; command_poll(); fake.recv_eof = 0U; }
|
||
command_connect();
|
||
CHECK(command_status.generation != event.request.generation);
|
||
CHECK(IEC104_Command_Report_Result(command, &event, IEC104_COMMAND_RESULT_FAILED) == IEC104_COMMAND_REPLY_STALE);
|
||
CHECK(IEC104_Command_Complete(command, &event) == IEC104_COMMAND_REPLY_STALE);
|
||
fake.sent_bytes = 0U; next_event = command_execute(45U, 1U);
|
||
(void)command_done(&next_event, IEC104_COMMAND_RESULT_SUCCEEDED);
|
||
CHECK(command_frame_count() == 2U && command_action_calls == 2U);
|
||
command_close();
|
||
}
|
||
++command_checks;
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:固定超时TERM仅适用于未取得执行结果:Complete/Handover仍按原寿命清理。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:期限0只禁用正向等待限制,时钟回退仍按执行超时收尾;返回信息未交接标志首次结束即冻结。
|
||
*/
|
||
static void test_command_timeout_term_boundaries(void)
|
||
{
|
||
unsigned mode;
|
||
for (mode = 0U; mode < 4U; ++mode) {
|
||
IEC104_CommandConfig_t config;
|
||
IEC104_CommandEvent_t event, finished;
|
||
uint64_t started;
|
||
command_config_default(&config); command_config_mode(&config, IEC104_COMMAND_MODE_DIRECT);
|
||
config.execute_timeout_ms = 0U;
|
||
config.complete_timeout_ms = 10U; config.handover_timeout_ms = 10U;
|
||
command_open(&config); event = command_execute(45U, 1U); command_flush();
|
||
started = fake.now;
|
||
if (mode < 2U) {
|
||
CHECK(IEC104_Command_Report_Result(command, &event, IEC104_COMMAND_RESULT_FAILED) == IEC104_COMMAND_REPLY_OK);
|
||
if (mode == 1U) {
|
||
command_leave_high_room(0U);
|
||
CHECK(IEC104_Command_Complete(command, &event) == IEC104_COMMAND_REPLY_OK);
|
||
command_process();
|
||
}
|
||
fake.now += 10U; finished = command_take(IEC104_COMMAND_FINISHED);
|
||
CHECK(finished.reason == (mode ? IEC104_COMMAND_FINISH_HANDOVER_TIMEOUT : IEC104_COMMAND_FINISH_COMPLETE_TIMEOUT));
|
||
CHECK(finished.execute_effect);
|
||
fake.send_blocked = 0U; command_flush();
|
||
CHECK(command_status.active && command_status.execute_timeouts == 0U);
|
||
CHECK(command_frame_count() == 1U);
|
||
} else if (mode == 2U) {
|
||
fake.now += 100000U; command_process(); command_empty();
|
||
CHECK(command_status.active && command_status.busy && !command_status.timer_active);
|
||
(void)command_done(&event, IEC104_COMMAND_RESULT_SUCCEEDED);
|
||
CHECK(command_frame_count() == 2U);
|
||
} else {
|
||
fake.now = started - 1U; finished = command_take(IEC104_COMMAND_FINISHED);
|
||
CHECK(finished.reason == IEC104_COMMAND_FINISH_EXECUTE_TIMEOUT && finished.execute_effect);
|
||
CHECK(IEC104_Command_Get_Status(command, &command_status));
|
||
CHECK(command_status.clock_errors == 1U && command_status.execute_timeouts == 1U);
|
||
CHECK(command_status.execution_failed == 0U && command_frame_count() == 1U);
|
||
fake.now = started; command_flush(); command_empty();
|
||
CHECK(command_frame_count() == 2U && command_status.active);
|
||
command_reply_at(1U, 45U, 0x4aU, 0x51U, 1U, 6001U, 1U);
|
||
}
|
||
command_close();
|
||
}
|
||
/* k=1让返回信息留在HIGH;FINISHED先报告保守未交接事实,随后ACK可继续发返回信息和TERM。 */
|
||
for (mode = 0U; mode < 2U; ++mode) {
|
||
IEC104_CommandConfig_t config;
|
||
IEC104_CommandEvent_t event, finished;
|
||
IEC60870_Asdu_t data;
|
||
uint8_t bytes[10];
|
||
command_config_default(&config); command_config_mode(&config, IEC104_COMMAND_MODE_DIRECT);
|
||
config.execute_timeout_ms = 10U;
|
||
if (mode == 1U) { command_window = 1U; }
|
||
command_open(&config); event = command_execute(45U, 1U); command_flush();
|
||
command_return(&data, bytes, 1U, 1U);
|
||
CHECK(IEC104_Command_Submit_Return_Info(command, &event, &data) == IEC104_COMMAND_REPLY_OK);
|
||
command_flush(); fake.now += 10U; command_process();
|
||
finished = command_take(IEC104_COMMAND_FINISHED);
|
||
CHECK(finished.reason == IEC104_COMMAND_FINISH_EXECUTE_TIMEOUT && finished.execute_effect);
|
||
CHECK(finished.return_info_undelivered == (mode != 0U));
|
||
if (mode) {
|
||
push_ack(1U); command_poll(); command_flush();
|
||
push_ack(2U); command_poll(); command_flush();
|
||
} else { command_flush(); }
|
||
command_empty();
|
||
CHECK(command_status.return_info_undelivered == mode);
|
||
CHECK(command_status.execute_timeouts == 1U && command_status.execution_failed == 0U);
|
||
CHECK(command_status.active && !command_status.busy && !command_status.need_process);
|
||
CHECK(command_frame_count() == 3U);
|
||
command_reply_at(1U, 1U, 11U, 0x51U, 1U, 1001U, 1U);
|
||
command_reply_at(2U, 45U, 0x4aU, 0x51U, 1U, 6001U, 1U);
|
||
command_close();
|
||
}
|
||
++command_checks;
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:肯定ACT_CON不得因执行到期被否定或删除。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:超时TERM排在它和旧忙回复之后。
|
||
* FINISHED先读后,残留回复仍有寿命;到期只清本事务,STOP/EOF清会话,均不重复FINISHED。
|
||
* ending=0正常解堵,1等待ENDED回复清理期限,2为STOP,3为EOF。
|
||
* ending=1仅丢弃原事务尚未交接的TERM并计一次dropped_replies,独立的旧忙回复继续发送。
|
||
*/
|
||
static void test_command_timeout_term_pending(void)
|
||
{
|
||
unsigned ending;
|
||
for (ending = 0U; ending < 4U; ++ending) {
|
||
IEC104_CommandConfig_t config;
|
||
IEC104_CommandEvent_t event, finished;
|
||
command_config_default(&config); command_config_mode(&config, IEC104_COMMAND_MODE_DIRECT);
|
||
config.execute_timeout_ms = 10U; config.handover_timeout_ms = 10U;
|
||
command_open(&config); event = command_execute(45U, 1U);
|
||
command_leave_high_room(0U);
|
||
command_send(45U, 6U, 0x52U, 1U, 6002U, 1U);
|
||
fake.now += 10U; finished = command_take(IEC104_COMMAND_FINISHED);
|
||
CHECK(finished.reason == IEC104_COMMAND_FINISH_EXECUTE_TIMEOUT && finished.execute_effect);
|
||
CHECK(IEC104_Command_Report_Result(command, &event, IEC104_COMMAND_RESULT_FAILED) == IEC104_COMMAND_REPLY_STALE);
|
||
command_process(); command_empty();
|
||
CHECK(command_status.pending_replies == 2U && command_status.busy && !command_status.need_process);
|
||
CHECK(command_frame_count() == 1U && command_action_calls == 1U);
|
||
if (ending == 1U) {
|
||
fake.now += 10U; command_empty(); command_process();
|
||
CHECK(!command_status.busy && command_status.pending_replies == 1U);
|
||
CHECK(command_status.dropped_replies == 1U && command_status.active);
|
||
} else if (ending >= 2U) {
|
||
if (ending == 2U) { push(stop_act, sizeof(stop_act)); }
|
||
else { fake.recv_eof = 1U; }
|
||
command_poll(); fake.recv_eof = 0U;
|
||
command_empty();
|
||
}
|
||
/* EOF可等待已编号的填充帧写完才交付DISCONNECTED;放行传输后再核对会话收尾。 */
|
||
fake.send_blocked = 0U; command_flush(); command_empty();
|
||
CHECK(command_status.execute_timeouts == 1U && command_status.execution_failed == 0U);
|
||
if (ending == 0U) {
|
||
CHECK(command_frame_count() == 3U);
|
||
command_reply_at(0U, 45U, 7U, 0x51U, 1U, 6001U, 1U);
|
||
command_reply_at(1U, 45U, 0x47U, 0x52U, 1U, 6002U, 1U);
|
||
command_reply_at(2U, 45U, 0x4aU, 0x51U, 1U, 6001U, 1U);
|
||
} else if (ending == 1U) {
|
||
CHECK(command_frame_count() == 2U);
|
||
command_reply_at(0U, 45U, 7U, 0x51U, 1U, 6001U, 1U);
|
||
command_reply_at(1U, 45U, 0x47U, 0x52U, 1U, 6002U, 1U);
|
||
} else {
|
||
CHECK(command_frame_count() == 1U);
|
||
CHECK(!command_status.busy && !command_status.active && command_status.pending_replies == 0U);
|
||
}
|
||
CHECK(command_action_calls == 1U && !command_status.timer_active && !command_status.need_process);
|
||
command_close();
|
||
}
|
||
/* 先占满k窗口,使肯定确认和旧忙回复仍留HIGH、一个字节都未写出。
|
||
* confirm_submitted只证明发送层已受理原确认,不代表它已编号、写出或得到主站ACK。
|
||
* 执行超时先交付FINISHED,随后逐个ACK推进原确认、旧回复、否定TERM,顺序不变。
|
||
* 第一次ACK释放占窗的填充帧,此后才轮到原确认;不能把执行超时误写成撤销已受理确认。 */
|
||
{
|
||
IEC104_CommandConfig_t config;
|
||
IEC104_CommandEvent_t event, finished;
|
||
IEC104_CommandTransactionInfo_t info;
|
||
IEC60870_Asdu_t filler;
|
||
uint8_t bytes[] = {200U, 0U, 3U, 0U, 1U, 0U};
|
||
unsigned acknowledged;
|
||
command_config_default(&config); command_config_mode(&config, IEC104_COMMAND_MODE_DIRECT);
|
||
config.execute_timeout_ms = 10U;
|
||
command_window = 1U; command_open(&config);
|
||
CHECK(IEC60870_Asdu_Create_From_Buffer(&filler,
|
||
IEC104_Slave_Get_Application_Layer_Parameters(command_slave), bytes, sizeof(bytes)) == IEC60870_ASDU_OK);
|
||
CHECK(IEC104_Slave_Enqueue_Event(command_slave, &filler) == IEC104_TCP_SUBMIT_OK);
|
||
command_poll(); event = command_execute(45U, 1U);
|
||
command_send(45U, 6U, 0x52U, 1U, 6002U, 1U);
|
||
fake.now += 10U; finished = command_take(IEC104_COMMAND_FINISHED);
|
||
CHECK(finished.reason == IEC104_COMMAND_FINISH_EXECUTE_TIMEOUT && finished.execute_effect);
|
||
CHECK(command_frame_count() == 0U);
|
||
CHECK(IEC104_Command_Get_Transaction(command, &event, &info));
|
||
CHECK(info.confirm_submitted && !info.term_submitted && !info.result_reported);
|
||
for (acknowledged = 1U; acknowledged <= 3U; ++acknowledged) {
|
||
push_ack((uint16_t)acknowledged); command_poll(); command_flush();
|
||
CHECK(command_frame_count() == acknowledged);
|
||
}
|
||
command_reply_at(0U, 45U, 7U, 0x51U, 1U, 6001U, 1U);
|
||
command_reply_at(1U, 45U, 0x47U, 0x52U, 1U, 6002U, 1U);
|
||
command_reply_at(2U, 45U, 0x4aU, 0x51U, 1U, 6001U, 1U);
|
||
CHECK(command_status.execute_timeouts == 1U && command_status.active && command_action_calls == 1U);
|
||
command_empty(); command_close();
|
||
}
|
||
++command_checks;
|
||
}
|
||
|
||
/* ============================================================================
|
||
* [COMMAND/RESELECT] 重复选择复归:旧许可失效、清理事件与必要否定的FIFO
|
||
* ============================================================================ */
|
||
/**
|
||
* 功能:验证以下场景与约束:十二种有S/E类型统一复归。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:覆盖SELECT未领取、已领取、已确认以及TEST模拟选择。
|
||
* 同OA和异OA均不得让第二条选择接管旧许可;否定回显第二条,FINISHED仍携带第一条。
|
||
* 旧执行必须重新经历选择,且应用只对曾领取的工作事件收到一次FINISHED。
|
||
*/
|
||
static void test_command_duplicate_select_reset(void)
|
||
{
|
||
static const unsigned types[] = {45U, 46U, 47U, 48U, 49U, 50U, 58U, 59U, 60U, 61U, 62U, 63U};
|
||
size_t index;
|
||
unsigned phase, other_oa;
|
||
for (index = 0U; index < sizeof(types) / sizeof(types[0]); ++index) {
|
||
for (phase = 0U; phase < 4U; ++phase) {
|
||
for (other_oa = 0U; other_oa < 2U; ++other_oa) {
|
||
IEC104_CommandConfig_t config;
|
||
IEC104_CommandEvent_t event = {0}, finished, next;
|
||
IEC104_CommandTransactionInfo_t info;
|
||
uint8_t original[32], repeated[32], execute[32];
|
||
size_t length;
|
||
unsigned test = phase == 3U ? 0x80U : 0U;
|
||
unsigned prior = phase >= 2U ? 1U : 0U;
|
||
command_timed_config(&config, types[index], 1000U);
|
||
command_config_mode(&config, IEC104_COMMAND_MODE_SELECT_EXECUTE);
|
||
command_open(&config);
|
||
CHECK(IEC104_Command_Set_Time_Base(command, command_epoch_ms, fake.now));
|
||
length = command_qualified_bytes(original, types[index], 6U | test, 0U, true);
|
||
command_raw_send(original, length);
|
||
if (phase == 1U || phase == 2U) { event = command_take(IEC104_COMMAND_SELECT); }
|
||
if (phase == 2U) {
|
||
CHECK(IEC104_Command_Accept(command, &event, command_action,
|
||
&command_action_calls) == IEC104_COMMAND_REPLY_OK);
|
||
}
|
||
command_flush();
|
||
memcpy(repeated, original, length);
|
||
repeated[3] = (uint8_t)(0x51U + other_oa);
|
||
command_raw_send(repeated, length); command_flush();
|
||
command_raw_reply_at(prior, repeated, length, 0x47U | test);
|
||
CHECK(command_frame_count() == prior + 1U && command_status.rejected == 1U);
|
||
CHECK(command_status.busy_rejected == 0U && command_status.dropped_requests == 0U);
|
||
CHECK(command_status.accepted == 1U && command_action_calls == (phase == 2U ? 1U : 0U));
|
||
if (phase == 1U || phase == 2U) {
|
||
CHECK(IEC104_Command_Accept(command, &event, command_action,
|
||
&command_action_calls) == IEC104_COMMAND_REPLY_STALE);
|
||
CHECK(IEC104_Command_Reject(command, &event,
|
||
IEC104_COMMAND_REJECT_NEGATIVE) == IEC104_COMMAND_REPLY_STALE);
|
||
CHECK(IEC104_Command_Get_Transaction(command, &event, &info) && !info.active &&
|
||
info.phase == IEC104_COMMAND_PHASE_ENDED);
|
||
finished = command_take(IEC104_COMMAND_FINISHED);
|
||
CHECK(finished.reason == IEC104_COMMAND_FINISH_DUPLICATE_SELECT &&
|
||
finished.transaction_id == event.transaction_id &&
|
||
finished.request.receive_serial == event.request.receive_serial &&
|
||
finished.request.originator_address == 0x51U);
|
||
CHECK(finished.select_effect == (phase == 2U) && !finished.execute_effect);
|
||
}
|
||
command_empty(); command_process();
|
||
CHECK(!command_status.busy && command_status.pending_replies == 0U);
|
||
CHECK(command_qualified_bytes(execute, types[index], 6U | test, 0U, false) == length);
|
||
command_raw_send(execute, length); command_flush(); command_empty();
|
||
command_raw_reply_at(prior + 1U, execute, length, 0x47U | test);
|
||
CHECK(!command_status.busy);
|
||
command_raw_send(original, length);
|
||
if (phase == 3U) { command_flush(); command_empty(); }
|
||
else {
|
||
next = command_take(IEC104_COMMAND_SELECT);
|
||
CHECK(next.transaction_id != event.transaction_id);
|
||
CHECK(IEC104_Command_Accept(command, &next, NULL, NULL) == IEC104_COMMAND_REPLY_OK);
|
||
command_flush();
|
||
}
|
||
command_raw_reply_at(prior + 2U, original, length, 7U | test);
|
||
CHECK(command_status.busy && command_status.accepted == 2U);
|
||
if (phase == 2U && other_oa != 0U) {
|
||
command_raw_send(execute, length);
|
||
next = command_take(IEC104_COMMAND_EXECUTE);
|
||
CHECK(next.transaction_id != event.transaction_id && next.request.selected);
|
||
CHECK(IEC104_Command_Accept(command, &next, command_action,
|
||
&command_action_calls) == IEC104_COMMAND_REPLY_OK);
|
||
(void)command_done(&next, IEC104_COMMAND_RESULT_SUCCEEDED);
|
||
command_raw_reply_at(prior + 3U, execute, length, 7U);
|
||
command_raw_reply_at(prior + 4U, execute, length, 10U);
|
||
CHECK(command_action_calls == 2U);
|
||
}
|
||
command_close();
|
||
}
|
||
}
|
||
}
|
||
++command_checks;
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:重复选择不要求命令值、合法QU或Type相同。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:该点允许的另一种选择同样结束旧许可。
|
||
* 已确认时保留原确认,第二条只得到否定,且从不产生第二个SELECT工作事件。
|
||
*/
|
||
static void test_command_duplicate_select_fields(void)
|
||
{
|
||
static const unsigned changed[][2] = {{45U, 0x80U}, {45U, 0x85U}, {46U, 0x82U}};
|
||
unsigned accepted, variant;
|
||
for (accepted = 0U; accepted < 2U; ++accepted) {
|
||
for (variant = 0U; variant < sizeof(changed) / sizeof(changed[0]); ++variant) {
|
||
IEC104_CommandEvent_t event, finished;
|
||
command_open(NULL); command_send(45U, 6U, 0x51U, 1U, 6001U, 0x81U);
|
||
event = command_take(IEC104_COMMAND_SELECT);
|
||
if (accepted != 0U) {
|
||
CHECK(IEC104_Command_Accept(command, &event, command_action,
|
||
&command_action_calls) == IEC104_COMMAND_REPLY_OK);
|
||
command_flush();
|
||
}
|
||
command_send(changed[variant][0], 6U, 0x51U, 1U, 6001U, changed[variant][1]);
|
||
command_flush();
|
||
command_reply_at(accepted, changed[variant][0], 0x47U, 0x51U, 1U, 6001U, changed[variant][1]);
|
||
finished = command_take(IEC104_COMMAND_FINISHED);
|
||
CHECK(finished.reason == IEC104_COMMAND_FINISH_DUPLICATE_SELECT &&
|
||
finished.request.type_id == 45U && finished.request.state == 1U &&
|
||
finished.request.qualifier == 0U && finished.transaction_id == event.transaction_id);
|
||
CHECK(command_action_calls == accepted && command_frame_count() == accepted + 1U);
|
||
command_empty(); command_close();
|
||
}
|
||
}
|
||
++command_checks;
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:独立短回复满池也不能阻止复归或丢失必要否定。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:更早的异点忙回复按FIFO保留。
|
||
* 覆盖SELECT_WAIT、已交接CON以及TEST未交接CON;TEST旧肯定确认必须撤掉。
|
||
* 真实Accept有动作前容量准入,使用TEST验证共用SELECTED状态下的模块持有CON。
|
||
* FINISHED先消费仍不能过早释放持有否定的事务槽,发送恢复后才完成回收。
|
||
*/
|
||
static void test_command_duplicate_select_backpressure(void)
|
||
{
|
||
unsigned phase, index;
|
||
for (phase = 0U; phase < 3U; ++phase) {
|
||
IEC104_CommandEvent_t event = {0}, finished;
|
||
IEC104_CommandTransactionInfo_t info;
|
||
unsigned test = phase == 2U ? 0x80U : 0U;
|
||
unsigned prior = phase == 1U ? 1U : 0U;
|
||
command_open(NULL);
|
||
if (phase == 2U) {
|
||
command_send(44U, 6U, 0x51U, 1U, 6001U, 1U);
|
||
command_congest();
|
||
}
|
||
command_send(45U, 6U | test, 0x51U, 1U, 6001U, 0x81U);
|
||
if (phase != 2U) {
|
||
event = command_take(IEC104_COMMAND_SELECT);
|
||
if (phase == 1U) {
|
||
CHECK(IEC104_Command_Accept(command, &event, command_action,
|
||
&command_action_calls) == IEC104_COMMAND_REPLY_OK);
|
||
command_flush();
|
||
CHECK(IEC104_Command_Get_Transaction(command, &event, &info) &&
|
||
info.phase == IEC104_COMMAND_PHASE_SELECTED && info.confirm_submitted);
|
||
}
|
||
command_congest();
|
||
}
|
||
for (index = 0U; index < IEC104_COMMAND_REPLY_CAPACITY; ++index) {
|
||
command_send(45U, 6U | test, 0x60U + index, 1U, 6002U, 0x81U);
|
||
}
|
||
command_process();
|
||
CHECK(command_status.pending_replies == IEC104_COMMAND_REPLY_CAPACITY + (phase >= 2U ? 1U : 0U));
|
||
command_send(46U, 6U | test, 0x52U, 1U, 6001U, 0x86U);
|
||
command_process();
|
||
CHECK(command_status.busy && command_status.pending_replies == IEC104_COMMAND_REPLY_CAPACITY + 1U);
|
||
CHECK(command_status.rejected == IEC104_COMMAND_REPLY_CAPACITY + 1U &&
|
||
command_status.busy_rejected == IEC104_COMMAND_REPLY_CAPACITY &&
|
||
command_status.overloads == 0U && command_status.dropped_requests == 0U);
|
||
CHECK(command_frame_count() == prior);
|
||
if (phase != 2U) {
|
||
CHECK(IEC104_Command_Accept(command, &event, command_action,
|
||
&command_action_calls) == IEC104_COMMAND_REPLY_STALE);
|
||
finished = command_take(IEC104_COMMAND_FINISHED);
|
||
CHECK(finished.reason == IEC104_COMMAND_FINISH_DUPLICATE_SELECT &&
|
||
finished.select_effect == (phase != 0U) && !finished.execute_effect);
|
||
}
|
||
command_empty(); command_process();
|
||
CHECK(command_status.busy && !IEC104_Command_Destroy(command));
|
||
fake.send_blocked = 0U; command_flush(); command_empty();
|
||
for (index = 0U; index < IEC104_COMMAND_REPLY_CAPACITY; ++index) {
|
||
command_reply_at(prior + index, 45U, 0x47U | test, 0x60U + index, 1U, 6002U, 0x81U);
|
||
}
|
||
command_reply_at(prior + index, 46U, 0x47U | test, 0x52U, 1U, 6001U, 0x86U);
|
||
CHECK(command_frame_count() == prior + index + 1U && !command_status.busy);
|
||
CHECK(command_status.pending_replies == 0U && command_status.negative_submitted == index + 1U);
|
||
CHECK(command_action_calls == (phase == 1U ? 1U : 0U));
|
||
command_close();
|
||
}
|
||
/* 已入HIGH的真实CON即使尚未编号也不再归Command所有。先填满k窗口,
|
||
* 复归后FINISHED立即可取;逐个ACK必须先写出旧肯定CON,再写第二条的否定CON。 */
|
||
{
|
||
IEC104_CommandEvent_t event, finished;
|
||
IEC104_CommandTransactionInfo_t info;
|
||
IEC60870_Asdu_t filler;
|
||
uint8_t bytes[] = {200U, 0U, 3U, 0U, 1U, 0U};
|
||
command_window = 1U; command_open(NULL);
|
||
CHECK(IEC60870_Asdu_Create_From_Buffer(&filler,
|
||
IEC104_Slave_Get_Application_Layer_Parameters(command_slave), bytes, sizeof(bytes)) == IEC60870_ASDU_OK);
|
||
CHECK(IEC104_Slave_Enqueue_Event(command_slave, &filler) == IEC104_TCP_SUBMIT_OK);
|
||
command_poll(); command_send(45U, 6U, 0x51U, 1U, 6001U, 0x81U);
|
||
event = command_take(IEC104_COMMAND_SELECT);
|
||
CHECK(IEC104_Command_Accept(command, &event, command_action,
|
||
&command_action_calls) == IEC104_COMMAND_REPLY_OK);
|
||
command_flush();
|
||
CHECK(IEC104_Command_Get_Transaction(command, &event, &info) && info.confirm_submitted);
|
||
CHECK(command_frame_count() == 0U);
|
||
command_send(45U, 6U, 0x52U, 1U, 6001U, 0x81U);
|
||
finished = command_take(IEC104_COMMAND_FINISHED);
|
||
CHECK(finished.reason == IEC104_COMMAND_FINISH_DUPLICATE_SELECT && finished.select_effect);
|
||
CHECK(IEC104_Command_Accept(command, &event, command_action,
|
||
&command_action_calls) == IEC104_COMMAND_REPLY_STALE);
|
||
CHECK(command_frame_count() == 0U);
|
||
for (index = 1U; index <= 2U; ++index) {
|
||
push_ack((uint16_t)index); command_poll(); command_flush();
|
||
CHECK(command_frame_count() == index);
|
||
}
|
||
command_reply_at(0U, 45U, 7U, 0x51U, 1U, 6001U, 0x81U);
|
||
command_reply_at(1U, 45U, 0x47U, 0x52U, 1U, 6001U, 0x81U);
|
||
CHECK(command_action_calls == 1U && !command_status.busy);
|
||
command_empty(); command_close();
|
||
}
|
||
++command_checks;
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:全局认识但点表禁用的选择、跨T选择和异点选择都不属于原事务的有效重复选择。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:原工作身份保持有效;EXECUTE_WAIT/EXECUTING中的选择也不能取消已接纳的执行。
|
||
*/
|
||
static void test_command_duplicate_select_isolation(void)
|
||
{
|
||
static const IEC104_CommandPoint_t points[] = {
|
||
{1U, 6001U, IEC104_COMMAND_TYPE_BIT(45U), IEC104_COMMAND_MODE_SELECT_EXECUTE},
|
||
{1U, 6002U, IEC104_COMMAND_TYPE_BIT(45U), IEC104_COMMAND_MODE_SELECT_EXECUTE}
|
||
};
|
||
unsigned phase;
|
||
for (phase = 0U; phase < 4U; ++phase) {
|
||
IEC104_CommandConfig_t config;
|
||
IEC104_CommandEvent_t event;
|
||
IEC104_CommandTransactionInfo_t before, after;
|
||
unsigned prior = 0U;
|
||
command_config_default(&config); config.points = points;
|
||
config.point_count = sizeof(points) / sizeof(points[0]);
|
||
command_open(&config); command_send(45U, 6U, 0x51U, 1U, 6001U, 0x81U);
|
||
event = command_take(IEC104_COMMAND_SELECT);
|
||
if (phase >= 1U) {
|
||
CHECK(IEC104_Command_Accept(command, &event, NULL, NULL) == IEC104_COMMAND_REPLY_OK);
|
||
command_flush(); ++prior;
|
||
}
|
||
if (phase >= 2U) {
|
||
command_send(45U, 6U, 0x51U, 1U, 6001U, 1U);
|
||
event = command_take(IEC104_COMMAND_EXECUTE);
|
||
}
|
||
if (phase == 3U) {
|
||
CHECK(IEC104_Command_Accept(command, &event, command_action,
|
||
&command_action_calls) == IEC104_COMMAND_REPLY_OK);
|
||
command_flush(); ++prior;
|
||
}
|
||
CHECK(IEC104_Command_Get_Transaction(command, &event, &before));
|
||
if (phase <= 1U) {
|
||
command_send(46U, 6U, 0x51U, 1U, 6001U, 0x82U); command_flush();
|
||
command_reply_at(prior++, 46U, 0x47U, 0x51U, 1U, 6001U, 0x82U);
|
||
} else {
|
||
command_send(45U, 6U, 0x52U, 1U, 6001U, 0x81U); command_flush();
|
||
command_reply_at(prior++, 45U, 0x47U, 0x52U, 1U, 6001U, 0x81U);
|
||
command_send(45U, 6U, 0x51U, 1U, 6001U, 0x81U); command_flush();
|
||
if (phase == 3U) { command_reply_at(prior++, 45U, 0x47U, 0x51U, 1U, 6001U, 0x81U); }
|
||
else { CHECK(command_status.dropped_requests == 1U); }
|
||
}
|
||
command_send(45U, 0x86U, 0x51U, 1U, 6001U, 0x81U); command_flush();
|
||
command_reply_at(prior++, 45U, 0xc7U, 0x51U, 1U, 6001U, 0x81U);
|
||
command_send(45U, 6U, 0x51U, 1U, 6002U, 0x81U); command_flush();
|
||
command_reply_at(prior++, 45U, 0x47U, 0x51U, 1U, 6002U, 0x81U);
|
||
command_empty();
|
||
CHECK(IEC104_Command_Get_Transaction(command, &event, &after) && after.active &&
|
||
after.phase == before.phase && after.confirm_submitted == before.confirm_submitted);
|
||
CHECK(command_frame_count() == prior);
|
||
if (phase == 0U) {
|
||
CHECK(IEC104_Command_Accept(command, &event, NULL, NULL) == IEC104_COMMAND_REPLY_OK);
|
||
command_flush();
|
||
}
|
||
if (phase < 2U) {
|
||
command_send(45U, 6U, 0x51U, 1U, 6001U, 1U);
|
||
event = command_take(IEC104_COMMAND_EXECUTE);
|
||
}
|
||
if (phase != 3U) {
|
||
CHECK(IEC104_Command_Accept(command, &event, command_action,
|
||
&command_action_calls) == IEC104_COMMAND_REPLY_OK);
|
||
}
|
||
(void)command_done(&event, IEC104_COMMAND_RESULT_SUCCEEDED);
|
||
CHECK(command_action_calls == 1U);
|
||
command_close();
|
||
}
|
||
++command_checks;
|
||
}
|
||
|
||
/* ============================================================================
|
||
* [COMMAND/TEST_BIT] T位模拟:原文确认、SBO状态和真实动作隔离
|
||
* ============================================================================ */
|
||
/**
|
||
* 功能:构造十四类合法模拟请求。
|
||
* 输入参数:bytes——报文字节缓冲区;type——协议类型或期望事件类型;cause——完整传送原因字节;selecting——是否构造选择阶段。
|
||
* 输出参数:bytes——写入或读出的数据字节。
|
||
* 返回值:生成报文或结果数据的实际字节长度。
|
||
* 说明:51/64没有S/E和限定词,保持完整32位值。
|
||
*/
|
||
static size_t command_test_bytes(uint8_t *bytes, unsigned type, unsigned cause, bool selecting)
|
||
{
|
||
static const uint8_t bits[] = {0xd5U, 0xaaU, 0x80U, 0xffU};
|
||
if (type == 51U || type == 64U) {
|
||
return type == 64U ? command_timed_bytes(bytes, type, cause | 0x80U, 0x51U, 1U, 6001U,
|
||
bits, sizeof(bits), command_epoch_time) : command_payload_bytes(bytes, type, cause | 0x80U,
|
||
0x51U, 1U, 6001U, bits, sizeof(bits));
|
||
}
|
||
return command_qualified_bytes(bytes, type, cause | 0x80U, 0U, selecting);
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:所有类型的DIRECT模拟只发送肯定CON/TERM,不生成供应用决定或执行的事件。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:十二种SBO类型先选择、再执行或撤销;每帧保留T/OA/值/限定词/原时标。
|
||
* 选择和执行统计属于真实动作,模拟只计协议accepted/completed及发送数。
|
||
*/
|
||
static void test_command_test_bit_flows(void)
|
||
{
|
||
static const unsigned types[] = {45U, 46U, 47U, 48U, 49U, 50U, 51U,
|
||
58U, 59U, 60U, 61U, 62U, 63U, 64U};
|
||
size_t index;
|
||
unsigned mode;
|
||
for (index = 0U; index < sizeof(types) / sizeof(types[0]); ++index) {
|
||
for (mode = 0U; mode < (types[index] == 51U || types[index] == 64U ? 1U : 3U); ++mode) {
|
||
IEC104_CommandConfig_t config;
|
||
uint8_t bytes[32], selected[32];
|
||
size_t length;
|
||
unsigned replies = 0U;
|
||
command_timed_config(&config, types[index], 1000U);
|
||
if (mode != 0U) { command_config_mode(&config, IEC104_COMMAND_MODE_SELECT_EXECUTE); }
|
||
command_open(&config);
|
||
CHECK(IEC104_Command_Set_Time_Base(command, command_epoch_ms, fake.now));
|
||
length = command_test_bytes(bytes, types[index], 6U, false);
|
||
if (mode != 0U) {
|
||
/* 无选择的测试执行同样否定;不能因为T位直接跳过SBO。 */
|
||
command_raw_send(bytes, length); command_flush(); command_empty();
|
||
command_raw_reply_at(replies++, bytes, length, 0xc7U);
|
||
CHECK(!command_status.busy && command_status.accepted == 0U);
|
||
CHECK(command_test_bytes(selected, types[index], 6U, true) == length);
|
||
command_raw_send(selected, length); command_flush(); command_empty();
|
||
command_raw_reply_at(replies++, selected, length, 0x87U);
|
||
CHECK(command_status.busy && command_status.timer_active && command_status.pending_events == 0U);
|
||
CHECK(command_status.timeout_remaining_ms == config.select_timeout_ms);
|
||
}
|
||
if (mode == 2U) { bytes[2] = 0x88U; }
|
||
command_raw_send(bytes, length); command_flush(); command_empty();
|
||
command_raw_reply_at(replies++, bytes, length, mode == 2U ? 0x89U : 0x87U);
|
||
if (mode != 2U) { command_raw_reply_at(replies++, bytes, length, 0x8aU); }
|
||
CHECK(command_frame_count() == replies && command_action_calls == 0U);
|
||
CHECK(command_status.selected == 0U && command_status.executed == 0U);
|
||
CHECK(command_status.completed == (mode == 2U ? 0U : 1U));
|
||
CHECK(command_status.return_info_submitted == 0U && !command_status.busy);
|
||
CHECK(!command_status.timer_active && !command_status.need_process && command_status.pending_events == 0U);
|
||
command_close();
|
||
}
|
||
}
|
||
++command_checks;
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:TEST激活/撤销不能命中同点真实SELECT_WAIT、SELECTED、EXECUTE_WAIT或EXECUTING。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:特别覆盖同OA:T必须先隔离,不能被同点静默重发分支吞掉,更不能清除真实选择。
|
||
* 原应用事件和阶段不变,之后真实动作仍只执行一次。
|
||
*/
|
||
static void test_command_test_bit_preserves_real(void)
|
||
{
|
||
unsigned phase, oa, cause;
|
||
for (phase = 0U; phase < 4U; ++phase) {
|
||
IEC104_CommandConfig_t config;
|
||
IEC104_CommandEvent_t event;
|
||
IEC104_CommandTransactionInfo_t before, after;
|
||
unsigned replies = 0U;
|
||
command_config_default(&config);
|
||
if (phase >= 2U) { command_config_mode(&config, IEC104_COMMAND_MODE_DIRECT); }
|
||
command_open(&config);
|
||
command_send(45U, 6U, 0x51U, 1U, 6001U, phase >= 2U ? 1U : 0x81U);
|
||
event = command_take(phase >= 2U ? IEC104_COMMAND_EXECUTE : IEC104_COMMAND_SELECT);
|
||
if (phase == 1U) {
|
||
CHECK(IEC104_Command_Accept(command, &event, NULL, NULL) == IEC104_COMMAND_REPLY_OK);
|
||
command_flush(); ++replies;
|
||
}
|
||
if (phase == 3U) {
|
||
CHECK(IEC104_Command_Accept(command, &event, command_action, &command_action_calls) == IEC104_COMMAND_REPLY_OK);
|
||
command_flush(); ++replies;
|
||
}
|
||
CHECK(IEC104_Command_Get_Transaction(command, &event, &before));
|
||
for (oa = 0x51U; oa <= 0x52U; ++oa) {
|
||
for (cause = 6U; cause <= 8U; cause += 2U) {
|
||
command_send(45U, cause | 0x80U, oa, 1U, 6001U, 1U);
|
||
command_flush(); command_empty();
|
||
command_reply_at(replies++, 45U, cause == 6U ? 0xc7U : 0xc9U, oa, 1U, 6001U, 1U);
|
||
CHECK(IEC104_Command_Get_Transaction(command, &event, &after));
|
||
CHECK(after.active && after.phase == before.phase && after.confirm_submitted == before.confirm_submitted);
|
||
CHECK(command_action_calls == (phase == 3U ? 1U : 0U) && command_status.dropped_requests == 0U);
|
||
}
|
||
}
|
||
if (phase == 0U) {
|
||
CHECK(IEC104_Command_Accept(command, &event, NULL, NULL) == IEC104_COMMAND_REPLY_OK);
|
||
command_flush();
|
||
}
|
||
if (phase < 2U) {
|
||
command_send(45U, 6U, 0x51U, 1U, 6001U, 1U);
|
||
event = command_take(IEC104_COMMAND_EXECUTE);
|
||
}
|
||
if (phase != 3U) {
|
||
CHECK(IEC104_Command_Accept(command, &event, command_action, &command_action_calls) == IEC104_COMMAND_REPLY_OK);
|
||
}
|
||
(void)command_done(&event, IEC104_COMMAND_RESULT_SUCCEEDED);
|
||
CHECK(command_action_calls == 1U && command_status.executed == 1U);
|
||
command_empty(); command_close();
|
||
}
|
||
++command_checks;
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:模拟选择不能被真实激活/撤销消费,也不能被其他OA的测试执行/撤销取消。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:非法QU必须在匹配前独立否定;同OA的值失配则按原SBO规则结束该模拟选择。
|
||
* 模拟选择占唯一槽;结束后可以立即开始正常真实业务。
|
||
*/
|
||
static void test_command_test_bit_identity(void)
|
||
{
|
||
unsigned mismatch;
|
||
for (mismatch = 0U; mismatch < 2U; ++mismatch) {
|
||
IEC104_CommandEvent_t event;
|
||
unsigned replies = 0U, variant;
|
||
command_open(NULL);
|
||
command_send(45U, 0x86U, 0x51U, 1U, 6001U, 0x81U); command_flush(); command_empty();
|
||
command_reply_at(replies++, 45U, 0x87U, 0x51U, 1U, 6001U, 0x81U);
|
||
for (variant = 0U; variant < 6U; ++variant) {
|
||
unsigned cause = (variant & 1U) ? 8U : 6U;
|
||
unsigned oa = variant < 2U || variant >= 4U ? 0x51U : 0x52U;
|
||
unsigned test = variant < 2U ? 0U : 0x80U;
|
||
unsigned value = variant >= 4U ? 0x11U : 1U;
|
||
command_send(45U, cause | test, oa, 1U, 6001U, value); command_flush(); command_empty();
|
||
command_reply_at(replies++, 45U, (cause == 6U ? 0x47U : 0x49U) | test, oa, 1U, 6001U, value);
|
||
CHECK(command_status.busy && command_status.pending_events == 0U && command_action_calls == 0U);
|
||
}
|
||
command_send(45U, mismatch ? 0x86U : 0x88U, 0x51U, 1U, 6001U, mismatch ? 0U : 1U);
|
||
command_flush(); command_empty();
|
||
command_reply_at(replies++, 45U, mismatch ? 0xc7U : 0x89U, 0x51U, 1U, 6001U, mismatch ? 0U : 1U);
|
||
CHECK(!command_status.busy && command_frame_count() == replies);
|
||
CHECK(command_status.mismatches == mismatch && command_status.selected == 0U && command_status.executed == 0U);
|
||
(void)command_select(45U, 1U);
|
||
event = command_execute(45U, 1U);
|
||
(void)command_done(&event, IEC104_COMMAND_RESULT_SUCCEEDED);
|
||
CHECK(command_action_calls == 2U);
|
||
command_close();
|
||
}
|
||
++command_checks;
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:T位不能绕过十二种限定词白名单、可信时间基准、IV或时差边界。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:negative_on_expired=false只作用于真实命令,测试过期必须给否定确认。
|
||
* 测试撤销的坏时标保持原模拟选择,随后新鲜撤销仍可成功。
|
||
*/
|
||
static void test_command_test_bit_validation(void)
|
||
{
|
||
static const unsigned types[] = {45U, 46U, 47U, 48U, 49U, 50U, 58U, 59U, 60U, 61U, 62U, 63U};
|
||
size_t index;
|
||
unsigned mode;
|
||
for (index = 0U; index < sizeof(types) / sizeof(types[0]); ++index) {
|
||
IEC104_CommandConfig_t config;
|
||
uint8_t bytes[32];
|
||
unsigned type = types[index];
|
||
size_t length;
|
||
command_timed_config(&config, type, 0U); command_open(&config);
|
||
length = command_qualified_bytes(bytes, type, 0x86U,
|
||
type <= 47U || (type >= 58U && type <= 60U) ? 4U : 1U, false);
|
||
command_raw_send(bytes, length); command_flush(); command_empty();
|
||
command_raw_reply_at(0U, bytes, length, 0xc7U);
|
||
CHECK(command_frame_count() == 1U && command_action_calls == 0U && !command_status.busy);
|
||
command_close();
|
||
}
|
||
for (mode = 0U; mode < 5U; ++mode) {
|
||
IEC104_CommandConfig_t config;
|
||
uint8_t bytes[32];
|
||
size_t length;
|
||
unsigned replies = 0U;
|
||
command_timed_config(&config, 58U, 1000U); config.negative_on_expired = false;
|
||
if (mode == 4U) { command_config_mode(&config, IEC104_COMMAND_MODE_SELECT_EXECUTE); }
|
||
command_open(&config);
|
||
if (mode != 0U) { CHECK(IEC104_Command_Set_Time_Base(command, command_epoch_ms, fake.now)); }
|
||
length = command_test_bytes(bytes, 58U, 6U, mode == 4U);
|
||
if (mode == 4U) {
|
||
command_raw_send(bytes, length); command_flush(); command_empty();
|
||
command_raw_reply_at(replies++, bytes, length, 0x87U);
|
||
bytes[2] = 0x88U;
|
||
}
|
||
if (mode == 1U) { bytes[length - 5U] |= 0x80U; }
|
||
else if (mode == 2U || mode == 4U) { fake.now += 1000U; }
|
||
else if (mode == 3U) { CHECK(IEC104_Command_Set_Time_Base(command, command_epoch_ms - 1000U, fake.now)); }
|
||
command_raw_send(bytes, length); command_flush(); command_empty();
|
||
command_raw_reply_at(replies++, bytes, length, 0xf1U);
|
||
CHECK(command_action_calls == 0U && command_status.accepted == (mode == 4U ? 1U : 0U));
|
||
CHECK(command_status.busy == (mode == 4U));
|
||
if (mode == 4U) {
|
||
CHECK(IEC104_Command_Set_Time_Base(command, command_epoch_ms, fake.now));
|
||
command_raw_send(bytes, length); command_flush(); command_empty();
|
||
command_raw_reply_at(replies++, bytes, length, 0x89U);
|
||
CHECK(!command_status.busy);
|
||
}
|
||
CHECK(command_frame_count() == replies); command_close();
|
||
}
|
||
++command_checks;
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:模拟确认也遵守HIGH背压、选择确认先于执行、CON先于TERM和交接期限。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:等待发送不生成工作事件,不要求无网络进展的忙轮询;解堵后不重复模拟事务。
|
||
*/
|
||
static void test_command_test_bit_backpressure(void)
|
||
{
|
||
unsigned selecting;
|
||
for (selecting = 0U; selecting < 2U; ++selecting) {
|
||
IEC104_CommandConfig_t config;
|
||
command_config_default(&config);
|
||
if (!selecting) { command_config_mode(&config, IEC104_COMMAND_MODE_DIRECT); }
|
||
command_open(&config);
|
||
/* 未支持类型只取得本连接纯值身份,不产生应答/事务,再用该身份填满HIGH。 */
|
||
command_send(44U, 6U, 0x51U, 1U, 6001U, 1U);
|
||
CHECK(command_last_handled == IEC104_COMMAND_EVENT_IGNORED);
|
||
command_leave_high_room(0U);
|
||
command_send(45U, 0x86U, 0x51U, 1U, 6001U, selecting ? 0x81U : 1U);
|
||
command_process(); command_empty();
|
||
CHECK(command_status.busy && command_status.pending_replies == (selecting ? 1U : 2U));
|
||
CHECK(!command_status.need_process && command_status.timer_active && command_action_calls == 0U);
|
||
if (selecting) {
|
||
command_send(45U, 0x86U, 0x51U, 1U, 6001U, 1U);
|
||
command_process(); command_empty();
|
||
CHECK(command_status.busy && command_status.pending_replies == 2U);
|
||
}
|
||
fake.send_blocked = 0U; command_flush(); command_empty();
|
||
command_reply_at(0U, 45U, 0x87U, 0x51U, 1U, 6001U, selecting ? 0x81U : 1U);
|
||
command_reply_at(1U, 45U, selecting ? 0xc7U : 0x8aU, 0x51U, 1U, 6001U, 1U);
|
||
if (selecting) {
|
||
command_send(45U, 0x86U, 0x51U, 1U, 6001U, 1U); command_flush(); command_empty();
|
||
command_reply_at(2U, 45U, 0x87U, 0x51U, 1U, 6001U, 1U);
|
||
command_reply_at(3U, 45U, 0x8aU, 0x51U, 1U, 6001U, 1U);
|
||
}
|
||
CHECK(command_frame_count() == (selecting ? 4U : 2U));
|
||
CHECK(!command_status.busy && !command_status.need_process && command_action_calls == 0U);
|
||
command_close();
|
||
}
|
||
++command_checks;
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:模拟选择沿用选择期限及Cancel/STOP/断线清理,但没有应用资源,所以始终无FINISHED。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:释放站点引用和唯一槽后,下一个真实选择仍能照常交应用;旧测试执行不能复活旧选择。
|
||
*/
|
||
static void test_command_test_bit_lifetime(void)
|
||
{
|
||
unsigned ending;
|
||
for (ending = 0U; ending < 4U; ++ending) {
|
||
IEC104_CommandConfig_t config;
|
||
command_config_default(&config); config.select_timeout_ms = 10U;
|
||
command_open(&config);
|
||
command_send(45U, 0x86U, 0x51U, 1U, 6001U, 0x81U); command_flush(); command_empty();
|
||
if (ending == 0U) { fake.now += 10U; command_process(); }
|
||
else if (ending == 1U) { IEC104_Command_Cancel(command); }
|
||
else if (ending == 2U) { push(stop_act, sizeof(stop_act)); command_poll(); }
|
||
else { fake.recv_eof = 1U; command_poll(); fake.recv_eof = 0U; }
|
||
command_flush(); command_empty();
|
||
CHECK(!command_status.busy && !command_status.timer_active && !command_status.need_process);
|
||
CHECK(command_action_calls == 0U && command_frame_count() == 1U);
|
||
if (ending == 2U) { push(start_act, sizeof(start_act)); command_poll(); }
|
||
else if (ending == 3U) { command_connect(); }
|
||
command_send(45U, 0x86U, 0x51U, 1U, 6001U, 1U); command_flush(); command_empty();
|
||
command_reply_at(1U, 45U, 0xc7U, 0x51U, 1U, 6001U, 1U);
|
||
CHECK(!command_status.busy && command_action_calls == 0U);
|
||
(void)command_select(45U, 1U);
|
||
CHECK(command_action_calls == 1U);
|
||
command_close();
|
||
}
|
||
++command_checks;
|
||
}
|
||
|
||
/* ============================================================================
|
||
* [COMMAND/ADDRESS] 撤销寻址:未知IOA、错误优先级、事务隔离与应答背压
|
||
* ============================================================================ */
|
||
/**
|
||
* 功能:验证以下场景与约束:十四种命令、真实/TEST均区分未知地址47与已知点无任务的否定9。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:低端0、相邻缺项、24位最大地址独立回显,防止只检查零地址或截成16位。
|
||
* 即使点表为空,已注册CA的未知地址也不能被描述成“没有可撤销事务”。
|
||
*/
|
||
static void test_command_deactivation_addresses(void)
|
||
{
|
||
static const unsigned types[] = {45U, 46U, 47U, 48U, 49U, 50U, 51U,
|
||
58U, 59U, 60U, 61U, 62U, 63U, 64U};
|
||
static const unsigned addresses[] = {0U, 6000U, 6001U, 6002U, 6003U, 0xffffffU};
|
||
size_t type_index, address_index;
|
||
unsigned test;
|
||
for (type_index = 0U; type_index < sizeof(types) / sizeof(types[0]); ++type_index) {
|
||
for (test = 0U; test <= 1U; ++test) {
|
||
IEC104_CommandConfig_t config;
|
||
uint8_t bytes[32];
|
||
size_t length;
|
||
command_timed_config(&config, types[type_index], 1000U);
|
||
command_open(&config);
|
||
CHECK(IEC104_Command_Set_Time_Base(command, command_epoch_ms, fake.now));
|
||
length = command_test_bytes(bytes, types[type_index], 8U, false);
|
||
bytes[2] = (uint8_t)(8U | (test ? 0x80U : 0U));
|
||
bytes[3] = 0x73U;
|
||
for (address_index = 0U; address_index < sizeof(addresses) / sizeof(addresses[0]); ++address_index) {
|
||
unsigned ioa = addresses[address_index];
|
||
unsigned reply = (ioa == 6001U || ioa == 6002U ? 0x49U : 0x6fU) | (test ? 0x80U : 0U);
|
||
bytes[6] = (uint8_t)ioa; bytes[7] = (uint8_t)(ioa >> 8); bytes[8] = (uint8_t)(ioa >> 16);
|
||
command_raw_send(bytes, length); command_flush(); command_empty();
|
||
CHECK(command_last_handled == IEC104_COMMAND_EVENT_HANDLED);
|
||
command_raw_reply_at((unsigned)address_index, bytes, length, reply);
|
||
CHECK(!command_status.busy && command_action_calls == 0U && command_status.accepted == 0U);
|
||
CHECK(command_status.rejected == address_index + 1U && command_status.busy_rejected == 0U);
|
||
CHECK(command_status.deactivated == 0U && command_status.pending_events == 0U);
|
||
}
|
||
CHECK(command_frame_count() == sizeof(addresses) / sizeof(addresses[0]));
|
||
command_close();
|
||
}
|
||
}
|
||
for (test = 0U; test <= 1U; ++test) {
|
||
IEC104_CommandConfig_t config;
|
||
IEC104_Command_Config_Default(&config);
|
||
command_open(&config);
|
||
command_send(45U, 8U | (test ? 0x80U : 0U), 0x73U, 1U, 6001U, 1U);
|
||
command_flush(); command_empty();
|
||
command_reply_at(0U, 45U, 0x6fU | (test ? 0x80U : 0U), 0x73U, 1U, 6001U, 1U);
|
||
CHECK(!command_status.busy && command_action_calls == 0U && command_status.accepted == 0U);
|
||
command_close();
|
||
}
|
||
++command_checks;
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:仅用包含完整单对象的报文检查错误优先级:未知COT45、未知CA46、未知IOA47
|
||
* 先于限定词/SQ拒绝。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:已知IOA的相同坏字段仍为否定9,不把已知点误报未知。
|
||
* 不支持的全局类型依旧交给外层44分派,覆盖见point_type_intersection。
|
||
*/
|
||
static void test_command_deactivation_address_precedence(void)
|
||
{
|
||
static const unsigned types[] = {45U, 49U, 58U, 62U};
|
||
size_t type_index;
|
||
unsigned test, variant;
|
||
for (type_index = 0U; type_index < sizeof(types) / sizeof(types[0]); ++type_index) {
|
||
for (test = 0U; test <= 1U; ++test) {
|
||
for (variant = 0U; variant < 6U; ++variant) {
|
||
IEC104_CommandConfig_t config;
|
||
uint8_t bytes[32];
|
||
unsigned type = types[type_index], flag = test ? 0x80U : 0U;
|
||
unsigned reply = variant == 1U ? 46U : (variant == 2U ? 45U :
|
||
(variant == 3U || variant == 4U ? 9U : 47U));
|
||
size_t length;
|
||
command_timed_config(&config, type, 1000U);
|
||
command_open(&config);
|
||
length = command_qualified_bytes(bytes, type, 8U | flag,
|
||
variant < 4U ? (type == 45U || type == 58U ? 9U : 64U) : 0U, false);
|
||
if (variant != 3U && variant != 4U) { bytes[6] += 2U; }
|
||
if (variant == 1U || variant == 2U) { bytes[4] = 2U; }
|
||
if (variant == 2U) { bytes[2] = (uint8_t)(5U | flag); }
|
||
if (variant >= 4U) { bytes[1] |= 0x80U; }
|
||
/* 无时间基准不会掩盖更早的寻址/格式错误,也不会触发实际动作。 */
|
||
command_raw_send(bytes, length); command_flush(); command_empty();
|
||
command_raw_reply_at(0U, bytes, length, reply | 0x40U | flag);
|
||
CHECK(command_frame_count() == 1U && command_status.rejected == 1U);
|
||
CHECK(command_status.time_rejected == 0U && !command_status.busy && command_action_calls == 0U);
|
||
command_close();
|
||
}
|
||
}
|
||
}
|
||
++command_checks;
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:未知地址撤销是独立错误回复:不能终结真实SELECT_WAIT、SELECTED、EXECUTE_WAIT
|
||
* 或测试SELECTED,也不能改写原应用事件/续期。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:随后原事务仍可执行或正常撤销。
|
||
* 同时发送真实和TEST撤销,确认错误回复镜像T而不依赖旧事务的T位。
|
||
*/
|
||
static void test_command_deactivation_address_isolation(void)
|
||
{
|
||
unsigned phase, test;
|
||
for (phase = 0U; phase < 4U; ++phase) {
|
||
IEC104_CommandConfig_t config;
|
||
IEC104_CommandEvent_t event;
|
||
IEC104_CommandTransactionInfo_t before, after;
|
||
unsigned replies = 0U;
|
||
command_config_default(&config);
|
||
config.decision_timeout_ms = 100U; config.select_timeout_ms = 100U;
|
||
if (phase == 2U) { command_config_mode(&config, IEC104_COMMAND_MODE_DIRECT); }
|
||
command_open(&config);
|
||
command_send(45U, phase == 3U ? 0x86U : 6U, 0x51U, 1U, 6001U, phase == 2U ? 1U : 0x81U);
|
||
if (phase != 3U) {
|
||
event = command_take(phase == 2U ? IEC104_COMMAND_EXECUTE : IEC104_COMMAND_SELECT);
|
||
if (phase == 1U) {
|
||
CHECK(IEC104_Command_Accept(command, &event, NULL, NULL) == IEC104_COMMAND_REPLY_OK);
|
||
}
|
||
}
|
||
command_flush(); command_empty();
|
||
if (phase != 3U) { CHECK(IEC104_Command_Get_Transaction(command, &event, &before)); }
|
||
replies = phase == 1U || phase == 3U ? 1U : 0U;
|
||
CHECK(command_status.timer_active && command_status.timeout_remaining_ms == 100U);
|
||
fake.now += 5U;
|
||
for (test = 0U; test <= 1U; ++test) {
|
||
unsigned flag = test ? 0x80U : 0U;
|
||
command_send(45U, 8U | flag, 0x51U, 1U, 6003U, 1U); command_flush(); command_empty();
|
||
command_reply_at(replies++, 45U, 0x6fU | flag, 0x51U, 1U, 6003U, 1U);
|
||
command_send(45U, 8U | flag, 0x51U, 1U, 6002U, 1U); command_flush(); command_empty();
|
||
command_reply_at(replies++, 45U, 0x49U | flag, 0x51U, 1U, 6002U, 1U);
|
||
CHECK(command_status.busy && command_status.accepted == 1U && command_action_calls == 0U);
|
||
CHECK(command_status.timer_active && command_status.timeout_remaining_ms == 95U);
|
||
CHECK(command_status.deactivated == 0U && command_status.pending_events == 0U);
|
||
if (phase != 3U) {
|
||
CHECK(IEC104_Command_Get_Transaction(command, &event, &after));
|
||
CHECK(after.active && after.phase == before.phase && after.confirm_submitted == before.confirm_submitted);
|
||
}
|
||
}
|
||
CHECK(command_frame_count() == replies && command_status.rejected == 4U);
|
||
if (phase == 3U) {
|
||
command_send(45U, 0x88U, 0x51U, 1U, 6001U, 1U); command_flush(); command_empty();
|
||
command_reply_at(replies++, 45U, 0x89U, 0x51U, 1U, 6001U, 1U);
|
||
CHECK(!command_status.busy && command_action_calls == 0U);
|
||
} else {
|
||
if (phase == 0U) {
|
||
CHECK(IEC104_Command_Accept(command, &event, NULL, NULL) == IEC104_COMMAND_REPLY_OK);
|
||
command_flush();
|
||
}
|
||
if (phase != 2U) {
|
||
command_send(45U, 6U, 0x51U, 1U, 6001U, 1U);
|
||
event = command_take(IEC104_COMMAND_EXECUTE);
|
||
}
|
||
CHECK(IEC104_Command_Accept(command, &event, command_action, &command_action_calls) == IEC104_COMMAND_REPLY_OK);
|
||
(void)command_done(&event, IEC104_COMMAND_RESULT_SUCCEEDED);
|
||
CHECK(command_action_calls == 1U && command_status.executed == 1U);
|
||
command_empty();
|
||
}
|
||
command_close();
|
||
}
|
||
++command_checks;
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:未知IOA的47沿用短回复FIFO和满槽丢新规则。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:HIGH完全阻塞时,原测试选择确认
|
||
* 必须先保留,后来错误回复不能改写它;解堵后按生成顺序发送,原选择仍可撤销。
|
||
* 该用例在1/4个短回复槽下运行,覆盖WAIT、实际容量边界及每帧原T/OA/IOA。
|
||
*/
|
||
static void test_command_deactivation_address_backpressure(void)
|
||
{
|
||
unsigned index;
|
||
command_open(NULL);
|
||
command_send(44U, 6U, 0x51U, 1U, 6001U, 1U);
|
||
CHECK(command_last_handled == IEC104_COMMAND_EVENT_IGNORED);
|
||
command_leave_high_room(0U);
|
||
command_send(45U, 0x86U, 0x51U, 1U, 6001U, 0x81U);
|
||
command_process(); command_empty();
|
||
for (index = 0U; index < IEC104_COMMAND_REPLY_CAPACITY + 1U; ++index) {
|
||
command_send(45U, 8U | ((index & 1U) ? 0x80U : 0U), 0x60U + index, 1U, 6003U + index, 1U);
|
||
command_process(); command_empty();
|
||
}
|
||
CHECK(command_frame_count() == 0U && command_status.busy && command_status.accepted == 1U);
|
||
CHECK(command_status.pending_replies == IEC104_COMMAND_REPLY_CAPACITY + 1U);
|
||
CHECK(command_status.overloads == 1U && command_status.dropped_requests == 1U && command_action_calls == 0U);
|
||
CHECK(command_status.rejected == IEC104_COMMAND_REPLY_CAPACITY + 1U && !command_status.need_process);
|
||
fake.send_blocked = 0U; command_flush(); command_empty();
|
||
command_reply_at(0U, 45U, 0x87U, 0x51U, 1U, 6001U, 0x81U);
|
||
for (index = 0U; index < IEC104_COMMAND_REPLY_CAPACITY; ++index) {
|
||
command_reply_at(index + 1U, 45U, 0x6fU | ((index & 1U) ? 0x80U : 0U),
|
||
0x60U + index, 1U, 6003U + index, 1U);
|
||
}
|
||
CHECK(command_frame_count() == IEC104_COMMAND_REPLY_CAPACITY + 1U && command_status.busy);
|
||
CHECK(command_status.pending_replies == 0U && command_status.pending_events == 0U);
|
||
command_send(45U, 0x88U, 0x51U, 1U, 6001U, 1U); command_flush(); command_empty();
|
||
command_reply_at(IEC104_COMMAND_REPLY_CAPACITY + 1U, 45U, 0x89U, 0x51U, 1U, 6001U, 1U);
|
||
CHECK(!command_status.busy && command_status.deactivated == 1U && command_action_calls == 0U);
|
||
command_close();
|
||
++command_checks;
|
||
}
|
||
|
||
/* ============================================================================
|
||
* [ENTRY/MAIN] 测试入口:基础、扩展、时标、点表及收尾分组
|
||
* ============================================================================ */
|
||
/**
|
||
* 功能:执行契约测试。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:正常完成返回 0;参数、运行或断言失败以非零状态结束进程。
|
||
* 说明:各组内部的类型、动作结果、期限及策略组合分别断言。
|
||
* 尺寸输出用于记录当前宿主ABI的公开结构布局,不当作MCU内存预算。
|
||
*/
|
||
int main(void)
|
||
{
|
||
/* [RUN/BASE] 基础配置、完整事务及动作结果 */
|
||
test_command_configuration();
|
||
test_command_wire_validation();
|
||
test_command_complete_flows();
|
||
test_command_result_policies();
|
||
test_command_action_outcomes();
|
||
test_command_rejection_and_stale();
|
||
test_command_application_reject_causes();
|
||
test_command_matching_and_busy();
|
||
/* [RUN/DUPLICATE] 决定期间重复请求 */
|
||
test_command_pending_same_point();
|
||
test_command_pending_other_originator();
|
||
test_command_pending_other_originator_overload();
|
||
test_command_pending_repeat_deadline();
|
||
test_command_pending_repeat_boundaries();
|
||
test_command_pending_repeat_lifetime();
|
||
test_command_duplicate_select_reset();
|
||
test_command_duplicate_select_fields();
|
||
test_command_duplicate_select_backpressure();
|
||
test_command_duplicate_select_isolation();
|
||
/* [RUN/LIFETIME] 终结、会话、引用与FIFO */
|
||
test_command_finished_pairing();
|
||
test_command_unsubmitted_selection();
|
||
test_command_deactivation_wait();
|
||
test_command_deadlines();
|
||
test_command_result_before_confirm();
|
||
test_command_fifo_and_overload();
|
||
test_command_return_validation();
|
||
test_command_stop_notifications();
|
||
test_command_disconnect_and_reuse();
|
||
test_command_station_lifetime();
|
||
test_command_reentry();
|
||
test_command_window_and_cancel();
|
||
test_command_two_services();
|
||
test_command_normal_overwrite();
|
||
test_command_stop_during_submit();
|
||
test_command_independent_reply_lifetime();
|
||
/* [RUN/EXTENDED] 47–51扩展命令 */
|
||
test_command_extended_configuration();
|
||
test_command_extended_flows();
|
||
test_command_extended_matching();
|
||
test_command_extended_invalid_values();
|
||
test_command_extended_wire_validation();
|
||
test_command_extended_reply_lengths();
|
||
/* [RUN/QUALIFIERS] QU/QL边界和既有事务隔离 */
|
||
test_command_qualifier_boundaries();
|
||
test_command_qualifier_preserves_transaction();
|
||
/* [RUN/TIMED] 58–64时标命令与时间基准 */
|
||
test_command_timed_flows();
|
||
test_command_time_conversion();
|
||
test_command_timed_auxiliary_fields();
|
||
test_command_timed_invalid_values();
|
||
test_command_timed_error_precedence();
|
||
test_command_deactivation_time_rules();
|
||
test_command_time_boundaries();
|
||
test_command_default_received_expiry();
|
||
test_command_time_base_errors();
|
||
test_command_time_base_api();
|
||
test_command_time_base_lifecycle();
|
||
test_command_time_configuration();
|
||
test_command_time_ordering();
|
||
test_command_time_base_reentry();
|
||
test_command_timed_reply_lengths();
|
||
test_command_timed_wire_validation();
|
||
/* [RUN/POINTS] 类型掩码及逐点配置 */
|
||
test_command_default_all_types();
|
||
test_command_point_default_empty();
|
||
test_command_point_configuration();
|
||
test_command_point_modes();
|
||
test_command_point_type_intersection();
|
||
test_command_point_ordering();
|
||
test_command_point_lookup_boundaries();
|
||
test_command_point_lifetime();
|
||
/* [RUN/RETURNS] 返回信息与应答尾部 */
|
||
test_command_response_tail();
|
||
test_command_continuous_events();
|
||
test_command_return_lifetime();
|
||
/* [RUN/ADMISSION] 动作前容量与旧回复门禁 */
|
||
test_command_accept_capacity();
|
||
test_command_accept_old_reply_gate();
|
||
#ifdef IEC104_COMMAND_TEST_HOOKS
|
||
test_command_capacity_query_faults();
|
||
#endif
|
||
/* [RUN/COMPLETION] 完成、交接及ENDED清理期限 */
|
||
test_command_complete_timeout();
|
||
test_command_handover_timeout();
|
||
test_command_completion_precedence();
|
||
test_command_ended_cleanup();
|
||
/* [RUN/ACTION_TIME] 动作前时效与凭证故障 */
|
||
test_command_action_time_expiry();
|
||
test_command_default_time_window();
|
||
test_command_action_time_rejections();
|
||
#ifdef IEC104_COMMAND_TEST_HOOKS
|
||
test_command_response_ticket_faults();
|
||
#endif
|
||
/* [RUN/ABNORMAL] 固定失败/超时TERM及其FIFO、会话和清理边界 */
|
||
test_command_action_failure_boundary();
|
||
test_command_negative_term_wait();
|
||
test_command_timeout_term_entries();
|
||
test_command_timeout_term_lifetime();
|
||
test_command_timeout_term_boundaries();
|
||
test_command_timeout_term_pending();
|
||
/* [RUN/TEST_BIT] 无动作模拟确认及T/OA、真实事务隔离 */
|
||
test_command_test_bit_flows();
|
||
test_command_test_bit_preserves_real();
|
||
test_command_test_bit_identity();
|
||
test_command_test_bit_validation();
|
||
test_command_test_bit_backpressure();
|
||
test_command_test_bit_lifetime();
|
||
/* [RUN/ADDRESS] 未知撤销地址与业务拒绝的原因码、身份及背压边界 */
|
||
test_command_deactivation_addresses();
|
||
test_command_deactivation_address_precedence();
|
||
test_command_deactivation_address_isolation();
|
||
test_command_deactivation_address_backpressure();
|
||
printf("Command tests passed: groups=%u tcp=%u replies=%u request=%zu event=%zu status=%zu\n",
|
||
command_checks, (unsigned)IEC104_TCP_SERVER_CAPACITY, (unsigned)IEC104_COMMAND_REPLY_CAPACITY,
|
||
sizeof(IEC104_CommandRequest_t), sizeof(IEC104_CommandEvent_t), sizeof(IEC104_CommandStatus_t));
|
||
return 0;
|
||
}
|