/* 参数模块状态机测试:请求经过真实 Slave/TCP 层,仅网络收发和单调时钟由夹具控制。 * 报文按原始字节构造和核对,避免用被测参数编解码器生成同源的期望结果。 * 导航:夹具与注入 -> 默认协议/确认取值 -> ACK 准备与收尾 -> 跨实例共享与预留。 * 构建矩阵为 TCP 容量 1/2 × 任务槽 1/4;容量不足的场景明确输出 SKIP。 * 本文件验证可控边界与计数;独立协议栈的互操作由 parameter_lib60870_client.c 验证。 */ #include "iec104_test_config.h" #include "iec104_tcp_fixture.h" #include "IEC104_Parameter.h" #ifndef IEC104_PARAMETER_TASK_CAPACITY #define IEC104_PARAMETER_TASK_CAPACITY 4U #endif #define P_APPLIED IEC104_PARAMETER_ACTION_APPLIED #define P_REJECTED IEC104_PARAMETER_ACTION_REJECTED #define P_STAGED IEC104_PARAMETER_ACTION_STAGED #define P_UNKNOWN IEC104_PARAMETER_ACTION_UNKNOWN_IOA #define P_ACK IEC104_PARAMETER_EXT_APPLY_ON_ACK static const IEC104_ParameterPoint_t points[] = { {1, 110, 1, 5001}, {1, 111, 1, 5002}, {1, 112, 2, 5003}, {1, 111, 3, 5004}, {1, 111, 4, 5005} }; static const IEC104_ParameterPoint_t shared_points[] = { {1, 111, 1, 5001}, {1, 112, 2, 5001}, {1, 111, 3, 5001}, {1, 110, 1, 5002} }; /* 两个实例故意借用同一份运行值;切换网络夹具不能切换或复制业务数据。 */ static IEC104_ParameterValue_t values[5]; typedef struct { IEC104_Slave_t *slave; IEC104_Parameter_t *module; IEC104_Station_t station; IEC104_ParameterConfig_t config; IEC104_ParameterStatus_t status; IEC104_SlaveEvent_t input; IEC104_ParameterEventResult_t handled; IEC104_ParameterRequest_t last, prepared; IEC104_ParameterActionResult_t result; unsigned ns, nr, calls, commits, aborts, prepares, tests; unsigned action_advance_ms; int send_fault, ack_error, round_value, reenter, check_station; bool timeout_abort, staged_valid; IEC104_ParameterValue_t staged_value; unsigned char net[sizeof(fake)]; } ParameterFixture; static ParameterFixture one; #if IEC104_TCP_SERVER_CAPACITY > 1 static ParameterFixture two; #endif static ParameterFixture *current; static unsigned groups; /** * 功能:多个服务沿用同一套模拟 socket 编号,只切换各连接的网络后端快照。 * 输入参数:f——测试夹具。 * 输出参数:无。 * 返回值:无。 * 说明:Slave、模块、站点和共享运行值的地址不变,仍遵守借用存储的寿命约束。 */ static void select_fixture(ParameterFixture *f) { if (current == f) { return; } if (current != NULL) { memcpy(current->net, &fake, sizeof(fake)); } current = f; memcpy(&fake, current->net, sizeof(fake)); } /** * 功能:刷新当前夹具的参数状态快照。 * 输入参数:无。 * 输出参数:无。 * 返回值:无。 * 说明:查询失败直接报告断言,不保留旧值继续判断。 */ static void status(void) { CHECK(IEC104_Parameter_Get_Status(current->module, ¤t->status)); } #ifdef IEC104_PARAMETER_TEST_HOOKS /** * 功能:1/2/3 分别强制提交 WAIT/ERROR/FATAL。 * 输入参数:slave——被测 Slave 实例。 * 输出参数:无。 * 返回值:发送提交结果,区分接收成功、WAIT、ERROR 与 FATAL。 * 说明:4 先让真实链路消费 STOPDT, * 暂不分派通知,再返回 ERROR,以覆盖“正常 STOP 待通知”的让出分支。 * 未注入时转调真实接口,会话查询和 ACK 观察槽分配也保持真实实现。 */ static IEC104_TcpSubmitResult_t submit_fault(IEC104_Slave_t *slave) { if (current->send_fault == 1) { return IEC104_TCP_SUBMIT_WAIT; } if (current->send_fault == 2) { return IEC104_TCP_SUBMIT_ERROR; } if (current->send_fault == 3) { return IEC104_TCP_SUBMIT_FATAL; } if (current->send_fault == 4) { push(stop_act, sizeof(stop_act)); CHECK(IEC104_Slave_Poll(slave, 0, NULL) == IEC104_TCP_OK); return IEC104_TCP_SUBMIT_ERROR; } return IEC104_TCP_SUBMIT_OK; } /** * 功能:在普通确认提交前应用发送故障注入。 * 输入参数:slave——被测 Slave 实例;identity——请求所属的 Slave、实例及连接代次身份(只读);response——响应 ASDU(只读)。 * 输出参数:无。 * 返回值:发送提交结果,区分接收成功、WAIT、ERROR 与 FATAL。 * 说明:未注入时仍走真实Slave发送链。 */ IEC104_TcpSubmitResult_t IEC104_Parameter_Test_Send_Response(IEC104_Slave_t *slave, const IEC104_SlaveEventIdentity_t *identity, const IEC60870_Asdu_t *response) { IEC104_TcpSubmitResult_t result = submit_fault(slave); return result == IEC104_TCP_SUBMIT_OK ? IEC104_Slave_Send_Response(slave, identity, response) : result; } /** * 功能:为带ACK观察的确认应用同一发送注入。 * 输入参数:slave——被测 Slave 实例;identity——请求所属的 Slave、实例及连接代次身份(只读);response——响应 ASDU(只读);receipt——带连接身份的 ACK 回执。 * 输出参数:receipt——提交成功时返回的 ACK 回执。 * 返回值:发送提交结果,区分接收成功、WAIT、ERROR 与 FATAL。 * 说明:正常路径由真实Slave分配和返回回执。 */ IEC104_TcpSubmitResult_t IEC104_Parameter_Test_Send_Response_Acked(IEC104_Slave_t *slave, const IEC104_SlaveEventIdentity_t *identity, const IEC60870_Asdu_t *response, IEC104_SlaveAckReceipt_t *receipt) { IEC104_TcpSubmitResult_t result = submit_fault(slave); return result == IEC104_TCP_SUBMIT_OK ? IEC104_Slave_Send_Response_Acked(slave, identity, response, receipt) : result; } /** * 功能:按夹具开关强制ACK查询错误,否则保持真实活动连接回执查询及确认时刻输出。 * 输入参数:slave——被测 Slave 实例(只读);receipt——带连接身份的 ACK 回执(只读);acked_at_ms——ACK 时刻(毫秒)的存储。 * 输出参数:acked_at_ms——已 ACK 时写入的确认时刻(毫秒)。 * 返回值:ACK 生命周期状态,区分排队、已发送、已确认及无效回执。 * 说明:本辅助入口用于构造或核对上述测试场景,相关状态保存在当前测试夹具中。 */ IEC104_SlaveAckState_t IEC104_Parameter_Test_Get_Active_Ack_State(const IEC104_Slave_t *slave, const IEC104_SlaveAckReceipt_t *receipt, uint64_t *acked_at_ms) { if (current->ack_error) { return IEC104_SLAVE_ACK_ERROR; } return IEC104_Slave_Get_Active_Ack_State(slave, receipt, acked_at_ms); } #endif /** * 功能:将 Slave 生命周期和 I 帧通知逐条分派给参数模块。 * 输入参数:无。 * 输出参数:无。 * 返回值:无。 * 说明:生命周期通知也必须逐条分派;暂存清理是应用职责,不由参数模块代管。 * 保存的 I 帧副本用于重入/旧代次测试,不能保留 NextEvent 的临时视图。 */ static void read_events(void) { IEC104_SlaveEvent_t event; IEC104_TcpEventResult_t result; while ((result = IEC104_Slave_NextEvent(current->slave, &event)) == IEC104_TCP_EVENT_READY) { IEC104_ParameterEventResult_t handled = IEC104_Parameter_Handle_Event(current->module, &event); CHECK(handled != IEC104_PARAMETER_EVENT_ERROR); if (event.transport.type == IEC104_TCP_EVENT_I_FRAME) { CHECK(IEC104_Slave_Copy_Event(¤t->input, &event)); current->handled = handled; } if (event.transport.type == IEC104_TCP_EVENT_DEACTIVATED || event.transport.type == IEC104_TCP_EVENT_DISCONNECTED) { current->staged_valid = false; } } CHECK(result == IEC104_TCP_EVENT_EMPTY); } /** * 功能:非阻塞推进Slave并排空通知。 * 输入参数:无。 * 输出参数:无。 * 返回值:无。 * 说明:轮询失败时先打印当前用例和序号便于定位。 */ static void poll_parameter(void) { IEC104_TcpResult_t result = IEC104_Slave_Poll(current->slave, 0, NULL); if (result != IEC104_TCP_OK) { fprintf(stderr, "poll: group=%u ns=%u result=%d\n", groups, current->ns, (int)result); } CHECK(result == IEC104_TCP_OK); read_events(); } /** * 功能:只推进传输和确认,不隐式 Execute_Next。 * 输入参数:无。 * 输出参数:无。 * 返回值:无。 * 说明:这样测试可分别观测动作与发送。 */ static void flush(void) { unsigned i; for (i = 0; i < 8; ++i) { poll_parameter(); CHECK(IEC104_Parameter_Process(current->module)); } status(); } /** * 功能:恢复共享运行值的测试基线,显式设置浮点参数及下限,供各用例独立起步。 * 输入参数:无。 * 输出参数:无。 * 返回值:无。 * 说明:本辅助入口用于构造或核对上述测试场景,相关状态保存在当前测试夹具中。 */ static void initial_values(void) { unsigned i; memset(values, 0, sizeof(values)); for (i = 0; i < 5; ++i) { values[i].scaled = 100; } values[2].short_float = 1.0f; values[3].scaled = 0; } /** * 功能:链路期限放宽,避免参数期限测试被 t1/t3 抢先结束。 * 输入参数:f——测试夹具;extensions——参数服务扩展功能位;timeout——等待或执行期限(毫秒);prepare_timeout——参数准备期限(毫秒);type_mask——允许的协议类型掩码。 * 输出参数:f——操作后的测试夹具和队列状态。 * 返回值:无。 * 说明:fake.now 从 1000 起算, * 既可测试到期相等边界,也可回退到受理时刻之前。Create 早于首条通知消费。 */ static void open_fixture_config(ParameterFixture *f, uint8_t extensions, uint32_t timeout, uint32_t prepare_timeout, uint8_t type_mask) { IEC104_SlaveConfig_t config; if (current != NULL) { memcpy(current->net, &fake, sizeof(fake)); } memset(f, 0, sizeof(*f)); current = f; memset(&fake, 0, sizeof(fake)); fake.now = 1000; f->result = P_APPLIED; f->slave = IEC104_Slave_Create(); CHECK(f->slave != NULL); test_transport_config(&config); config.protocol.link.k = 32; config.protocol.link.t1_ms = 600000; config.protocol.link.t3_ms = 600000; config.protocol.local_send_timeout_ms = 600000; CHECK(IEC104_Slave_Init(f->slave, &config, NULL) == IEC104_TCP_OK); CHECK(IEC104_Slave_Add_Station(f->slave, &f->station, 1, f) == IEC104_STATION_OK); IEC104_Parameter_Config_Default(&f->config); f->config.points = points; f->config.point_count = sizeof(points) / sizeof(points[0]); f->config.values = values; f->config.extensions = extensions; f->config.execute_timeout_ms = timeout; f->config.prepare_timeout_ms = prepare_timeout; f->config.type_mask = type_mask; if ((extensions & IEC104_PARAMETER_EXT_SHARED_IOA) != 0U) { f->config.points = shared_points; f->config.point_count = sizeof(shared_points) / sizeof(shared_points[0]); } f->module = IEC104_Parameter_Create(f->slave, &f->config); CHECK(f->module != NULL); fake.accept_pending = 1; poll_parameter(); push(start_act, sizeof(start_act)); poll_parameter(); status(); CHECK(f->status.active); } /** * 功能:使用全部参数类型和10ms准备期限建立夹具,扩展开关及执行期限由调用者指定。 * 输入参数:f——测试夹具;extensions——参数服务扩展功能位;timeout——等待或执行期限(毫秒)。 * 输出参数:f——操作后的测试夹具和队列状态。 * 返回值:无。 * 说明:本辅助入口用于构造或核对上述测试场景,相关状态保存在当前测试夹具中。 */ static void open_fixture(ParameterFixture *f, uint8_t extensions, uint32_t timeout) { open_fixture_config(f, extensions, timeout, 10, 15); } /** * 功能:可编排的同步动作:EXECUTE 写运行值,PREPARE 只保存请求,收尾才提交或放弃。 * 输入参数:context——业务回调的测试上下文;request——当前业务请求(只读)。 * 输出参数:无。 * 返回值:业务动作结果,保留应用成功、业务拒绝及未知对象等协议区别。 * 说明:逐字段比较准备与收尾身份/原值,专门捕获“确认带旧值却覆盖请求原文”的错误。 * 回调内同时验证状态快照与重入屏障;TEST 提前返回,绝不写运行值或暂存。 */ static IEC104_ParameterActionResult_t action(void *context, const IEC104_ParameterRequest_t *request) { ParameterFixture *f = context; CHECK(f == current); status(); f->last = *request; ++f->calls; CHECK(request->station_id == IEC104_Station_Get_Id(&f->station)); CHECK(request->common_address == 1 && request->originator_address == 0x5A); if (request->phase == IEC104_PARAMETER_PHASE_COMMIT || request->phase == IEC104_PARAMETER_PHASE_ABORT) { if (!f->timeout_abort) { CHECK(!f->status.confirm_pending); } CHECK(request->accepted_ms == f->prepared.accepted_ms); CHECK(request->receive_serial == f->prepared.receive_serial && request->generation == f->prepared.generation); CHECK(request->instance_id == f->prepared.instance_id && request->type_id == f->prepared.type_id); CHECK(memcmp(&request->value, &f->prepared.value, sizeof(request->value)) == 0); if (request->phase == IEC104_PARAMETER_PHASE_ABORT) { ++f->aborts; if (f->timeout_abort) { CHECK(f->status.confirm_pending); } } else { ++f->commits; if (request->operation == IEC104_PARAMETER_OP_LOAD) { if (request->prepared == P_STAGED) { f->staged_value = request->value; f->staged_valid = true; } else { values[request->point_index] = request->value; } } } return P_REJECTED; /* 故意返回拒绝,验证 COMMIT/ABORT 的返回值不再生成确认。 */ } CHECK(f->status.confirm_pending); if (f->reenter) { IEC104_ParameterStatus_t before = f->status; CHECK(IEC104_Parameter_Execute_Next(f->module, action, f) == IEC104_PARAMETER_EXECUTE_ERROR); CHECK(!IEC104_Parameter_Process(f->module)); CHECK(IEC104_Parameter_Handle_Event(f->module, &f->input) == IEC104_PARAMETER_EVENT_ERROR); CHECK(!IEC104_Parameter_Destroy(f->module)); IEC104_Parameter_Cancel(f->module); status(); CHECK(memcmp(&before, &f->status, sizeof(before)) == 0); } if (request->test) { ++f->tests; CHECK(request->phase == IEC104_PARAMETER_PHASE_EXECUTE); return f->result; } if (f->check_station && !IEC104_Station_Is_Registered(&f->station)) { return P_REJECTED; } if (request->phase == IEC104_PARAMETER_PHASE_PREPARE) { ++f->prepares; f->prepared = *request; fake.now += f->action_advance_ms; return f->result; } if (request->operation == IEC104_PARAMETER_OP_LOAD) { CHECK(request->point_span == 1 && request->kind == f->config.points[request->point_index].kind); if (f->result == P_APPLIED) { values[request->point_index] = request->value; if (f->round_value && request->type_id == 111) { values[request->point_index].scaled = (int16_t)(request->value.scaled / 10 * 10); } } else if (f->result == P_STAGED) { f->staged_valid = true; f->staged_value = request->value; } } return f->result; } /** * 功能:将当前夹具及动作回调交给一次Execute_Next,原样返回是否执行、等待或失败。 * 输入参数:无。 * 输出参数:无。 * 返回值:单步执行结果,区分已执行、无任务、等待及错误。 * 说明:本辅助入口用于构造或核对上述测试场景,相关状态保存在当前测试夹具中。 */ static IEC104_ParameterExecuteResult_t execute(void) { return IEC104_Parameter_Execute_Next(current->module, action, current); } /** * 功能:先 Cancel 固定 ACK 收尾决定并释放回执,再关闭 Slave。 * 输入参数:f——测试夹具。 * 输出参数:f——操作后的测试夹具和队列状态。 * 返回值:无。 * 说明:动作上下文、站点和 * 借用数组一直保留到全部收尾交付。Destroy 成功后才释放站点与服务对象。 */ static void close_fixture(ParameterFixture *f) { unsigned guard = 0; select_fixture(f); f->send_fault = f->ack_error = 0; IEC104_Parameter_Cancel(f->module); CHECK(IEC104_Slave_Close(f->slave, NULL) == IEC104_TCP_OK); read_events(); status(); while (f->status.finish_pending) { CHECK(++guard < 8); CHECK(execute() == IEC104_PARAMETER_EXECUTE_OK); status(); } CHECK(IEC104_Parameter_Destroy(f->module)); if (IEC104_Station_Is_Registered(&f->station)) { CHECK(IEC104_Slave_Remove_Station(f->slave, &f->station) == IEC104_STATION_OK); } CHECK(IEC104_Station_Is_Reusable(&f->station)); CHECK(IEC104_Slave_Destroy(f->slave, NULL) == IEC104_TCP_OK); current = NULL; } /** * 功能:按当前N(S)/N(R)包装原始ASDU并入接收队列,仅递增发送序号,不推进Slave。 * 输入参数:bytes——报文字节缓冲区(只读);length——字节长度。 * 输出参数:无。 * 返回值:无。 * 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。 */ static void queue_bytes(const uint8_t *bytes, size_t length) { uint8_t frame[255] = {0x68}; CHECK(length <= 249); frame[1] = (uint8_t)(length + 4); frame[2] = (uint8_t)(current->ns << 1); frame[3] = (uint8_t)(current->ns >> 7); frame[4] = (uint8_t)(current->nr << 1); frame[5] = (uint8_t)(current->nr >> 7); ++current->ns; memcpy(frame + 6, bytes, length); push(frame, length + 6); } /** * 功能:独立线格式构造器:value 是字段原始位模式,浮点用例无需先经过宿主 float。 * 输入参数:bytes——报文字节缓冲区;type——协议类型或期望事件类型;cot——完整传送原因字节;ca——公共地址;ioa——信息对象地址;value——测试对象值或原始位模式;qualifier——原始限定词。 * 输出参数:bytes——写入或读出的数据字节。 * 返回值:生成报文或结果数据的实际字节长度。 * 说明:cot 含 TEST/P/N 位,qualifier 保留整字节,便于核对错误镜像和限定词回显。 */ static size_t request_bytes(uint8_t *bytes, unsigned type, unsigned cot, unsigned ca, unsigned ioa, uint32_t value, unsigned qualifier) { size_t length = type == 113 ? 10U : type == 112 ? 14U : 12U; memset(bytes, 0, 32); bytes[0] = (uint8_t)type; bytes[1] = 1; bytes[2] = (uint8_t)cot; bytes[3] = 0x5A; 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; bytes[10] = (uint8_t)(value >> 8); bytes[11] = (uint8_t)(value >> 16); bytes[12] = (uint8_t)(value >> 24); bytes[length - 1U] = (uint8_t)qualifier; return length; } /** * 功能:构造CA=1的参数请求并立即轮询分派,应用动作与确认处理仍由用例显式推进。 * 输入参数:type——协议类型或期望事件类型;cot——完整传送原因字节;ioa——信息对象地址;value——测试对象值或原始位模式;qualifier——原始限定词。 * 输出参数:无。 * 返回值:无。 * 说明:本辅助入口用于构造或核对上述测试场景,相关状态保存在当前测试夹具中。 */ static void send_request(unsigned type, unsigned cot, unsigned ioa, uint32_t value, unsigned qualifier) { uint8_t bytes[32]; size_t length = request_bytes(bytes, type, cot, 1, ioa, value, qualifier); queue_bytes(bytes, length); poll_parameter(); } /** * 功能:从累计输出提取Type110..113的ASDU借用视图及长度。 * 输入参数:frames——按线上顺序排列的 ASDU 视图数组;lengths——各 ASDU 的长度数组。 * 输出参数:frames——按线上顺序排列的 ASDU 视图数组;lengths——各 ASDU 的长度数组。 * 返回值:本次收集或统计到的有效业务帧数量。 * 说明:调用者须提供64项结果数组。 */ static unsigned collect(const uint8_t **frames, size_t *lengths) { unsigned count = 0; size_t offset = 0; while (offset < fake.sent_bytes) { const uint8_t *frame = fake.output + offset; size_t length = (size_t)frame[1] + 2; CHECK(length >= 6 && offset + length <= fake.sent_bytes); if ((frame[2] & 1U) == 0 && frame[6] >= 110 && frame[6] <= 113) { CHECK(count < 64); frames[count] = frame + 6; lengths[count++] = length - 6; } offset += length; } return count; } /** * 功能:独立构造预期参数ASDU并逐字节核对指定确认,失败时打印每字节实际值和期望值。 * 输入参数:index——待访问或核对的条目下标;type——协议类型或期望事件类型;cot——完整传送原因字节;ca——公共地址;ioa——信息对象地址;value——测试对象值或原始位模式;qualifier——原始限定词。 * 输出参数:无。 * 返回值:无。 * 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。 */ static void expect_reply(unsigned index, unsigned type, unsigned cot, unsigned ca, unsigned ioa, uint32_t value, unsigned qualifier) { const uint8_t *frames[64]; size_t lengths[64], length; uint8_t expected[32]; length = request_bytes(expected, type, cot, ca, ioa, value, qualifier); CHECK(collect(frames, lengths) > index); CHECK(lengths[index] == length); if (memcmp(frames[index], expected, length) != 0) { size_t i; fprintf(stderr, "group %u reply %u actual/expected:", groups, index); for (i = 0; i < length; ++i) { fprintf(stderr, " %02X/%02X", frames[index][i], expected[i]); } fputc('\n', stderr); CHECK(0); } } /** * 功能:只确认已经出现在输出线上的 I 帧。 * 输入参数:无。 * 输出参数:无。 * 返回值:无。 * 说明:正常请求不自动推进 nr,ACK 时机由用例决定。 */ static void ack_all(void) { size_t offset = 0; unsigned nr = current->nr; while (offset < fake.sent_bytes) { const uint8_t *frame = fake.output + offset; if ((frame[2] & 1U) == 0) { nr = (((unsigned)frame[3] << 7) | (frame[2] >> 1)) + 1U; } offset += (size_t)frame[1] + 2; } current->nr = nr; push_ack(nr); poll_parameter(); CHECK(IEC104_Parameter_Process(current->module)); status(); } /** * 功能:验证以下场景与约束:[默认配置] 穷举 KPA 字节并检查表排序、借用指针和扩展约束。 * 输入参数:无。 * 输出参数:无。 * 返回值:无。 * 说明:只启用 113 * 可以没有运行值,但启用 QPA=2 时仍必须提供用于寻址的点表。 */ static void test_configuration(void) { IEC104_Slave_t *slave = IEC104_Slave_Create(); IEC104_ParameterConfig_t config, bad; IEC104_ParameterPoint_t rows[2] = {{1, 111, 1, 1}, {1, 112, 2, 2}}; IEC104_Parameter_t *module; unsigned kind; CHECK(slave != NULL); IEC104_Parameter_Config_Default(NULL); IEC104_Parameter_Config_Default(&config); CHECK(config.type_mask == 15 && config.extensions == 0 && config.execute_timeout_ms == 15000 && config.prepare_timeout_ms == 15000 && config.points == NULL && config.values == NULL); CHECK(IEC104_Parameter_Create(slave, &config) == NULL); CHECK(IEC104_Parameter_Create(NULL, &config) == NULL && IEC104_Parameter_Create(slave, NULL) == NULL); config.points = rows; config.point_count = 2; config.values = values; #define BAD_CONFIG(field, value) do { bad = config; bad.field = (value); CHECK(IEC104_Parameter_Create(slave, &bad) == NULL); } while (0) BAD_CONFIG(type_mask, 0); BAD_CONFIG(type_mask, 0x10); BAD_CONFIG(extensions, 0x20); BAD_CONFIG(points, NULL); BAD_CONFIG(point_count, 0); BAD_CONFIG(values, NULL); BAD_CONFIG(point_count, SIZE_MAX / sizeof(rows[0]) + 1U); for (kind = 0; kind < 256; ++kind) { rows[0].kind = (uint8_t)kind; module = IEC104_Parameter_Create(slave, &config); CHECK((module != NULL) == ((kind >= 1 && kind <= 4) || (kind >= 32 && kind <= 63))); if (module != NULL) { CHECK(IEC104_Parameter_Destroy(module)); } } rows[0].kind = 1; rows[0].common_address = 0; CHECK(IEC104_Parameter_Create(slave, &config) == NULL); rows[0].common_address = 65535; CHECK(IEC104_Parameter_Create(slave, &config) == NULL); rows[0].common_address = 1; rows[0].ioa = 0; CHECK(IEC104_Parameter_Create(slave, &config) == NULL); rows[0].ioa = 0x1000000; CHECK(IEC104_Parameter_Create(slave, &config) == NULL); rows[0].ioa = 1; rows[0].type_id = 113; CHECK(IEC104_Parameter_Create(slave, &config) == NULL); rows[0].type_id = 111; rows[1].ioa = 1; CHECK(IEC104_Parameter_Create(slave, &config) == NULL); config.extensions = IEC104_PARAMETER_EXT_SHARED_IOA; module = IEC104_Parameter_Create(slave, &config); CHECK(module != NULL); CHECK(IEC104_Parameter_Destroy(module)); rows[1].kind = 1; CHECK(IEC104_Parameter_Create(slave, &config) == NULL); rows[1].kind = 2; rows[1].ioa = 2; config.extensions = 0; config.type_mask = IEC104_PARAMETER_TYPE_BIT(113); config.values = NULL; module = IEC104_Parameter_Create(slave, &config); CHECK(module != NULL); CHECK(IEC104_Parameter_Destroy(module)); config.points = NULL; config.point_count = 0; BAD_CONFIG(extensions, IEC104_PARAMETER_EXT_QPA_OBJECT); module = IEC104_Parameter_Create(slave, &config); CHECK(module != NULL); CHECK(IEC104_Parameter_Create(slave, &config) == NULL); CHECK(IEC104_Parameter_Destroy(module)); CHECK(IEC104_Slave_Destroy(slave, NULL) == IEC104_TCP_OK); CHECK(!IEC104_Parameter_Destroy(NULL) && !IEC104_Parameter_Process(NULL)); CHECK(IEC104_PARAMETER_TYPE_BIT(109) == 0 && IEC104_PARAMETER_TYPE_BIT(114) == 0); ++groups; #undef BAD_CONFIG } /** * 功能:验证以下场景与约束:[运行值确认] 三种类型分别核对 APPLIED 新值、REJECTED 旧值、UNKNOWN 镜像。 * 输入参数:无。 * 输出参数:无。 * 返回值:无。 * 说明:另用 205 -> 200 的应用取整证明肯定确认取实际运行值,而非固定回显请求。 */ static void test_load_results(void) { unsigned type, result; for (type = 110; type <= 112; ++type) { for (result = 0; result < 4; ++result) { uint32_t sent = type == 112 ? 0x40000000U : 205; uint32_t old = type == 112 ? 0x3F800000U : 100; unsigned ioa = 5001 + type - 110, kind = type == 112 ? 2 : 1; initial_values(); open_fixture(&one, 0, 15000); one.result = result == 3 ? (IEC104_ParameterActionResult_t)99 : (IEC104_ParameterActionResult_t)result; send_request(type, 6, ioa, sent, kind | 0xC0); CHECK(one.calls == 0 && one.handled == IEC104_PARAMETER_EVENT_HANDLED); CHECK(execute() == IEC104_PARAMETER_EXECUTE_OK); flush(); expect_reply(0, type, result == 1 ? 7 : result == 2 ? 0x6F : 0x47, 1, ioa, result == 1 || result == 2 ? sent : old, kind | 0xC0); CHECK(one.last.local_change && one.last.not_in_operation && one.status.executed == 1); CHECK(one.status.applied == (result == 1) && one.status.unknown_ioa == (result == 2)); close_fixture(&one); } } initial_values(); open_fixture(&one, 0, 15000); one.round_value = 1; send_request(111, 6, 5002, 205, 1); CHECK(execute() == IEC104_PARAMETER_EXECUTE_OK); flush(); expect_reply(0, 111, 7, 1, 5002, 200, 1); close_fixture(&one); ++groups; } /** * 功能:验证COT/CA/IOA/内容的拒绝优先级、对象数量异常及全部QPA字节的处理结果。 * 输入参数:无。 * 输出参数:无。 * 返回值:无。 * 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。 */ static void test_validation(void) { /* 同时制造多项错误,核对 COT -> CA -> IOA -> 内容的判定优先级。 */ static const struct { unsigned type, cot, ca, ioa, qualifier, vsq, tail, reply; uint32_t value; } cases[] = { {111, 8, 65535, 999, 0, 0x81, 1, 0x6D, 200}, {111, 6, 65535, 999, 0, 0x81, 1, 0x6E, 200}, {111, 6, 2, 5002, 1, 1, 0, 0x6E, 200}, {111, 6, 1, 999, 0, 0x81, 1, 0x6F, 200}, {110, 6, 1, 5002, 1, 1, 0, 0x47, 200}, {111, 6, 1, 5002, 2, 1, 0, 0x47, 200}, {111, 6, 1, 5002, 1, 0x81, 0, 0x47, 100}, {111, 6, 1, 5002, 1, 1, 1, 0x47, 100}, {111, 0x46, 1, 5002, 1, 1, 0, 0x47, 100}, {111, 0xC6, 1, 5002, 1, 1, 0, 0xC7, 100}, {113, 8, 1, 1, 0, 1, 0, 0x49, 0} }; unsigned i; for (i = 0; i < sizeof(cases) / sizeof(cases[0]); ++i) { uint8_t bytes[32]; size_t n; initial_values(); open_fixture(&one, 0, 15000); n = request_bytes(bytes, cases[i].type, cases[i].cot, cases[i].ca, cases[i].ioa, 200, cases[i].qualifier); bytes[1] = (uint8_t)cases[i].vsq; queue_bytes(bytes, n + cases[i].tail); poll_parameter(); flush(); expect_reply(0, cases[i].type, cases[i].reply, cases[i].ca, cases[i].ioa, cases[i].value, cases[i].qualifier); CHECK(one.calls == 0 && one.status.rejected == 1 && one.status.accepted == 0); close_fixture(&one); } for (i = 0; i < 3; ++i) { uint8_t bytes[32]; size_t n; initial_values(); open_fixture(&one, 0, 15000); n = request_bytes(bytes, 111, 6, 1, 5002, 200, 1); bytes[1] = i == 0 ? 0 : 2; if (i == 2) { memcpy(bytes + n, bytes + 6, 6); n += 6; } queue_bytes(bytes, n); poll_parameter(); flush(); /* 声明两个对象却只带一个载荷时由 Receiver 断链,不计模块 rejected。 * VSQ=0 和完整双对象帧能到模块,由模块丢弃且不发送确认。 */ CHECK(one.status.rejected == (i != 1) && one.status.submitted == 0 && one.status.pending_requests == 0); if (i == 1) { CHECK(!one.status.active); } close_fixture(&one); } for (i = 0; i < 256; ++i) { initial_values(); open_fixture(&one, 0, 15000); send_request(113, 6, 999, 0, i); if (i == 3) { one.result = P_UNKNOWN; CHECK(execute() == IEC104_PARAMETER_EXECUTE_OK); } flush(); expect_reply(0, 113, i == 3 ? 0x6F : 0x47, 1, 999, 0, i); close_fixture(&one); } ++groups; } /** * 功能:验证以下场景与约束:[浮点原文] 正负 Inf、静默/信号 NaN 均拒绝。 * 输入参数:无。 * 输出参数:无。 * 返回值:无。 * 说明:负零、最小非规格化数和最大 * 有限数均受理,确保判断只看 IEEE 754 指数位,不受浮点优化选项影响。 */ static void test_float_bits(void) { static const uint32_t bits[] = {0x7F800000U, 0xFF800000U, 0x7FC12345U, 0x7F800001U, 0x80000000U, 1U, 0x7F7FFFFFU}; unsigned i; for (i = 0; i < sizeof(bits) / sizeof(bits[0]); ++i) { initial_values(); open_fixture(&one, 0, 15000); send_request(112, 6, 5003, bits[i], 2); if (i >= 4) { CHECK(execute() == IEC104_PARAMETER_EXECUTE_OK); } flush(); expect_reply(0, 112, i < 4 ? 0x47 : 7, 1, 5003, i < 4 ? 0x3F800000U : bits[i], 2); CHECK(one.status.rejected == (i < 4)); close_fixture(&one); } ++groups; } /** * 功能:验证以下场景与约束:[TEST] 即使动作预设为拒绝,110..112 也只验证协议并返回当前值。 * 输入参数:无。 * 输出参数:无。 * 返回值:无。 * 说明:113 仍需 * 只读动作判断地址。开启 ACK 扩展也不得把 TEST 变成 PREPARE 或等待 ACK。 */ static void test_test_bit(void) { unsigned type, result; for (type = 110; type <= 112; ++type) { initial_values(); open_fixture(&one, P_ACK, 15000); one.result = P_REJECTED; send_request(type, 0x86, 5001 + type - 110, type == 112 ? 0xBF800000U : 0xFFFFU, type == 112 ? 2 : 1); CHECK(execute() == IEC104_PARAMETER_EXECUTE_EMPTY); flush(); expect_reply(0, type, 0x87, 1, 5001 + type - 110, type == 112 ? 0x3F800000U : 100, type == 112 ? 2 : 1); CHECK(one.calls == 0 && one.status.accepted == 1 && one.status.executed == 0 && !one.status.ack_pending); close_fixture(&one); } for (result = 0; result < 3; ++result) { initial_values(); open_fixture(&one, P_ACK, 15000); one.result = (IEC104_ParameterActionResult_t)result; send_request(113, 0x88, 2001, 0, 3); CHECK(execute() == IEC104_PARAMETER_EXECUTE_OK); flush(); expect_reply(0, 113, result == 0 ? 0xC9 : result == 1 ? 0x89 : 0xEF, 1, 2001, 0, 3); CHECK(one.tests == 1 && one.prepares == 0 && one.status.executed == 0 && one.status.applied == 0 && one.status.unknown_ioa == 0 && !one.status.ack_pending); close_fixture(&one); } ++groups; } /** * 功能:验证以下场景与约束:[执行期限/重试] 覆盖截止前、恰好截止、时钟倒退和禁用期限。 * 输入参数:无。 * 输出参数:无。 * 返回值:无。 * 说明:确认第一次 * WAIT 后再改运行值,最终字节仍须保持首次快照,且动作不能重复调用。 */ static void test_deadlines_and_retry(void) { unsigned mode; for (mode = 0; mode < 4; ++mode) { initial_values(); open_fixture(&one, 0, mode == 3 ? 0 : 10); send_request(111, 6, 5002, 200, 1); status(); CHECK(one.status.timer_active == (mode != 3)); fake.now = mode == 2 ? 999 : mode == 0 ? 1009 : 1010; CHECK(execute() == (mode == 0 || mode == 3 ? IEC104_PARAMETER_EXECUTE_OK : IEC104_PARAMETER_EXECUTE_EMPTY)); if (fake.now < 1000) { fake.now = 1000; } flush(); expect_reply(0, 111, mode == 0 || mode == 3 ? 7 : 0x47, 1, 5002, mode == 0 || mode == 3 ? 200 : 100, 1); CHECK(one.status.timeouts == (mode == 1 || mode == 2)); close_fixture(&one); } initial_values(); open_fixture(&one, 0, 15000); one.send_fault = 1; send_request(111, 6, 5002, 200, 1); CHECK(execute() == IEC104_PARAMETER_EXECUTE_OK); values[1].scaled = 300; CHECK(IEC104_Parameter_Process(one.module)); one.send_fault = 0; flush(); expect_reply(0, 111, 7, 1, 5002, 200, 1); CHECK(one.calls == 1 && one.status.waits >= 2 && one.status.executed == 1); close_fixture(&one); ++groups; } /** * 功能:验证以下场景与约束:[FIFO 取值] A 装载 1、B TEST、C 装载 2、D 装载 3。 * 输入参数:无。 * 输出参数:无。 * 返回值:无。 * 说明:连续执行可越过待发确认, * B 必须在 C 动作前取值,四份确认恒为 1/1/2/3;有无发送 WAIT 都要成立。 */ static void test_fifo(void) { #if IEC104_PARAMETER_TASK_CAPACITY >= 4 unsigned wait; for (wait = 0; wait < 2; ++wait) { initial_values(); open_fixture(&one, 0, 15000); send_request(111, 6, 5002, 1, 1); send_request(111, 0x86, 5002, 99, 1); send_request(111, 6, 5002, 2, 1); send_request(111, 6, 5002, 3, 1); one.send_fault = (int)wait; CHECK(execute() == IEC104_PARAMETER_EXECUTE_OK); CHECK(execute() == IEC104_PARAMETER_EXECUTE_OK); CHECK(execute() == IEC104_PARAMETER_EXECUTE_OK); CHECK(execute() == IEC104_PARAMETER_EXECUTE_EMPTY); one.send_fault = 0; flush(); expect_reply(0, 111, 7, 1, 5002, 1, 1); expect_reply(1, 111, 0x87, 1, 5002, 1, 1); expect_reply(2, 111, 7, 1, 5002, 2, 1); expect_reply(3, 111, 7, 1, 5002, 3, 1); CHECK(one.status.accepted == 4 && one.status.executed == 3); close_fixture(&one); } #else puts("SKIP FIFO four-request snapshot: task capacity < 4"); #endif ++groups; } /** * 功能:验证以下场景与约束:[取消与过载] 合法请求和错误确认共用容量。 * 输入参数:无。 * 输出参数:无。 * 返回值:无。 * 说明:槽满只丢新。动作已生效后发送 * 失败不回滚;站点删除后引用仍保留到任务移除,由动作决定拒绝旧站请求。 */ static void test_overload_and_lifetime(void) { unsigned i, fault; initial_values(); open_fixture(&one, 0, 15000); for (i = 0; i < IEC104_PARAMETER_TASK_CAPACITY; ++i) { send_request(111, 6, 5002, 200, 1); } send_request(111, 6, 5002, 200, 1); send_request(111, 8, 5002, 200, 1); status(); CHECK(one.status.accepted == IEC104_PARAMETER_TASK_CAPACITY && one.status.dropped_requests == 2 && one.status.rejected == 1 && one.status.pending_requests == IEC104_PARAMETER_TASK_CAPACITY); CHECK(!IEC104_Parameter_Destroy(one.module)); IEC104_Parameter_Cancel(one.module); status(); CHECK(one.status.cancelled == IEC104_PARAMETER_TASK_CAPACITY); close_fixture(&one); for (fault = 2; fault <= 4; ++fault) { initial_values(); open_fixture(&one, 0, 15000); one.send_fault = (int)fault; send_request(111, 6, 5002, 200, 1); CHECK(execute() == IEC104_PARAMETER_EXECUTE_OK); read_events(); status(); CHECK(one.status.pending_requests == 0 && one.status.cancelled == 1); CHECK(values[1].scaled == 200); close_fixture(&one); } initial_values(); open_fixture(&one, 0, 15000); one.reenter = 1; send_request(111, 6, 5002, 200, 1); CHECK(execute() == IEC104_PARAMETER_EXECUTE_OK); close_fixture(&one); initial_values(); open_fixture(&one, 0, 15000); one.check_station = 1; send_request(111, 6, 5002, 200, 1); CHECK(IEC104_Slave_Remove_Station(one.slave, &one.station) == IEC104_STATION_OK); CHECK(!IEC104_Station_Is_Reusable(&one.station)); CHECK(execute() == IEC104_PARAMETER_EXECUTE_OK); flush(); expect_reply(0, 111, 0x47, 1, 5002, 100, 1); close_fixture(&one); ++groups; } /** * 功能:验证以下场景与约束:[扩展开关] 穷举全部 32 种组合。 * 输入参数:无。 * 输出参数:无。 * 返回值:无。 * 说明:用 TEST 隔离 QPA 受理规则与 ACK 收尾。 * 后半段验证 STAGED 合法范围、QPA=1/2 地址、专用 QPA 和同址 KPA 定位。 */ static void test_extensions(void) { unsigned ext, qpa; for (ext = 0; ext <= IEC104_PARAMETER_EXT_ALL; ++ext) { for (qpa = 1; qpa <= 3; ++qpa) { bool accepted = qpa == 3 || (qpa == 1 && (ext & IEC104_PARAMETER_EXT_QPA_LOADED)) || (qpa == 2 && (ext & IEC104_PARAMETER_EXT_QPA_OBJECT)); initial_values(); open_fixture(&one, (uint8_t)ext, 15000); send_request(113, 0x86, qpa == 1 ? 0 : 5001, 0, qpa); CHECK(execute() == (accepted ? IEC104_PARAMETER_EXECUTE_OK : IEC104_PARAMETER_EXECUTE_EMPTY)); flush(); expect_reply(0, 113, accepted ? 0x87 : 0xC7, 1, qpa == 1 ? 0 : 5001, 0, qpa); if (accepted && qpa == 2) { CHECK(one.last.point_index == 0 && one.last.point_span == ((ext & IEC104_PARAMETER_EXT_SHARED_IOA) ? 3U : 1U)); } close_fixture(&one); } } for (qpa = 128; qpa <= 255; qpa += 127) { initial_values(); open_fixture(&one, IEC104_PARAMETER_EXT_PRIVATE_QPA, 15000); send_request(113, 8, 0xFFFFFF, 0, qpa); CHECK(execute() == IEC104_PARAMETER_EXECUTE_OK); flush(); expect_reply(0, 113, 9, 1, 0xFFFFFF, 0, qpa); CHECK(one.last.point_index == SIZE_MAX); close_fixture(&one); } for (ext = 0; ext < 3; ++ext) { initial_values(); open_fixture(&one, (uint8_t)ext, 15000); one.result = P_STAGED; send_request(111, 6, 5002, 200, 1); CHECK(execute() == IEC104_PARAMETER_EXECUTE_OK); flush(); expect_reply(0, 111, ext ? 7 : 0x47, 1, 5002, 100, 1); CHECK(one.status.staged == (ext != 0)); close_fixture(&one); } initial_values(); open_fixture(&one, IEC104_PARAMETER_EXT_QPA_LOADED | IEC104_PARAMETER_EXT_QPA_OBJECT, 15000); send_request(113, 6, 1, 0, 1); flush(); expect_reply(0, 113, 0x6F, 1, 1, 0, 1); send_request(113, 6, 999, 0, 2); flush(); expect_reply(1, 113, 0x6F, 1, 999, 0, 2); one.result = P_STAGED; send_request(113, 6, 0, 0, 1); CHECK(execute() == IEC104_PARAMETER_EXECUTE_OK); flush(); expect_reply(2, 113, 0x47, 1, 0, 0, 1); CHECK(one.status.staged == 0); close_fixture(&one); initial_values(); open_fixture(&one, IEC104_PARAMETER_EXT_SHARED_IOA, 15000); values[1].short_float = 1.0f; send_request(112, 6, 5001, 0x40000000, 2); CHECK(execute() == IEC104_PARAMETER_EXECUTE_OK); flush(); CHECK(one.last.point_index == 1); expect_reply(0, 112, 7, 1, 5001, 0x40000000, 2); send_request(111, 6, 5001, 200, 4); flush(); expect_reply(1, 111, 0x47, 1, 5001, 200, 4); send_request(111, 6, 5001, 200, 2); flush(); expect_reply(2, 111, 0x47, 1, 5001, 200, 2); close_fixture(&one); ++groups; } /** * 功能:验证以下场景与约束:[ACK 两阶段] 后续请求不自动确认前帧,准备、网络 ACK 和应用收尾可独立观测。 * 输入参数:无。 * 输出参数:无。 * 返回值:无。 * 说明:ACK 后再 STOP:APPLIED 仍提交,STAGED 必须放弃;未 ACK 或观察失败均放弃。 * 健康连接 Cancel 后的迟到 ACK 也不能把已放弃的准备重新提交。 */ static void test_ack_success_and_loss(void) { unsigned staged, ending; for (staged = 0; staged < 2; ++staged) { for (ending = 0; ending < 4; ++ending) { initial_values(); open_fixture(&one, P_ACK | IEC104_PARAMETER_EXT_QPA_LOADED, 15000); one.result = staged ? P_STAGED : P_APPLIED; send_request(111, 6, 5002, 200, 1); CHECK(execute() == IEC104_PARAMETER_EXECUTE_OK); flush(); expect_reply(0, 111, 7, 1, 5002, staged ? 100 : 200, 1); CHECK(values[1].scaled == 100 && one.prepares == 1 && one.status.ack_pending); CHECK(!one.status.confirm_pending && !one.status.execute_ready && !one.status.need_process); CHECK(!IEC104_Parameter_Destroy(one.module)); if (ending == 0 || ending == 1) { ack_all(); CHECK(one.status.finish_pending); } if (ending == 1 || ending == 2) { push(stop_act, sizeof(stop_act)); poll_parameter(); } if (ending == 3) { one.ack_error = 1; CHECK(IEC104_Parameter_Process(one.module)); } CHECK(execute() == IEC104_PARAMETER_EXECUTE_OK); status(); CHECK(one.commits == ((ending == 0 || ending == 1) && !(staged && ending == 1))); CHECK(one.aborts == (1U - one.commits)); CHECK(one.last.value.scaled == 200); CHECK(execute() == IEC104_PARAMETER_EXECUTE_EMPTY); CHECK(values[1].scaled == ((!staged && one.commits) ? 200 : 100)); CHECK(one.status.ack_errors == (ending == 3)); close_fixture(&one); } } initial_values(); open_fixture(&one, P_ACK, 15000); send_request(111, 6, 5002, 200, 1); CHECK(execute() == IEC104_PARAMETER_EXECUTE_OK); flush(); IEC104_Parameter_Cancel(one.module); CHECK(execute() == IEC104_PARAMETER_EXECUTE_OK); ack_all(); CHECK(execute() == IEC104_PARAMETER_EXECUTE_EMPTY && one.aborts == 1 && one.commits == 0); close_fixture(&one); ++groups; } /** * 功能:验证以下场景与约束:[准备超时] 持续 WAIT 使肯定确认从未交出。 * 输入参数:无。 * 输出参数:无。 * 返回值:无。 * 说明:到期只排入 ABORT,Process 不调用 * 动作。ABORT 后才生成否定确认;在其前/后 Cancel 都只取消一次确认义务。 */ static void test_prepare_timeout(void) { unsigned cancel_mode, rollback; for (cancel_mode = 0; cancel_mode < 3; ++cancel_mode) { for (rollback = 0; rollback < 2; ++rollback) { initial_values(); open_fixture(&one, P_ACK, 15000); one.send_fault = 1; send_request(111, 6, 5002, 200, 1); CHECK(execute() == IEC104_PARAMETER_EXECUTE_OK); status(); CHECK(one.status.timer_active && one.status.timeout_remaining_ms == 10); fake.now = rollback ? 999 : 1010; CHECK(IEC104_Parameter_Process(one.module)); status(); CHECK(one.status.prepare_timeouts == 1 && one.status.finish_pending && one.status.execute_ready); CHECK(one.aborts == 0 && one.status.pending_requests == 1); if (cancel_mode == 1) { IEC104_Parameter_Cancel(one.module); } one.timeout_abort = cancel_mode != 1; CHECK(execute() == IEC104_PARAMETER_EXECUTE_OK); status(); CHECK(one.aborts == 1 && one.status.pending_requests == (cancel_mode != 1)); if (cancel_mode == 2) { IEC104_Parameter_Cancel(one.module); } one.send_fault = 0; fake.now = 1010; flush(); CHECK(one.status.cancelled == (cancel_mode != 0)); CHECK(one.status.submitted == (cancel_mode == 0)); if (cancel_mode == 0) { expect_reply(0, 111, 0x47, 1, 5002, 100, 1); } CHECK(execute() == IEC104_PARAMETER_EXECUTE_EMPTY && one.aborts == 1); close_fixture(&one); } } ++groups; } /** * 功能:验证以下场景与约束:[两个期限起点] 动作内推进时钟,证明 prepared_ms 从返回时起算,原 accepted_ms * 仍交给收尾。 * 输入参数:无。 * 输出参数:无。 * 返回值:无。 * 说明:执行已开始后不再按执行期限中断,准备期限为 0 时也不判倒退。 */ static void test_prepare_clock_and_disabled_deadline(void) { unsigned disabled; for (disabled = 0; disabled < 2; ++disabled) { initial_values(); open_fixture_config(&one, P_ACK, 1, disabled ? 0 : 10, 15); one.action_advance_ms = 7; one.send_fault = 1; send_request(111, 6, 5002, 200, 1); CHECK(execute() == IEC104_PARAMETER_EXECUTE_OK); status(); CHECK(one.prepared.accepted_ms == 1000 && fake.now == 1007); CHECK(one.status.timer_active == !disabled && one.status.timeout_remaining_ms == (disabled ? 0U : 10U)); CHECK(one.status.timeouts == 0); /* 动作已开始,即使返回时越过执行期限也不超时。 */ fake.now = disabled ? 999 : 1016; CHECK(IEC104_Parameter_Process(one.module)); status(); CHECK(one.status.prepare_timeouts == 0 && !one.status.finish_pending); CHECK(one.status.timeout_remaining_ms == (disabled ? 0U : 1U)); fake.now = disabled ? 20000 : 1017; CHECK(IEC104_Parameter_Process(one.module)); status(); CHECK(one.status.prepare_timeouts == !disabled); if (!disabled) { one.timeout_abort = true; CHECK(execute() == IEC104_PARAMETER_EXECUTE_OK); } one.send_fault = 0; flush(); if (disabled) { ack_all(); CHECK(execute() == IEC104_PARAMETER_EXECUTE_OK); CHECK(one.commits == 1); } else { CHECK(one.aborts == 1); } CHECK(one.last.accepted_ms == 1000); close_fixture(&one); } ++groups; } /** * 功能:验证以下场景与约束:[提交故障] 肯定准备尚未成功交出就遇 ERROR/FATAL/STOP,任务必须保留到 ABORT, * 不得因取消普通任务的路径提前释放。 * 输入参数:无。 * 输出参数:无。 * 返回值:无。 * 说明:运行值保持旧值。 */ static void test_ack_submission_faults(void) { unsigned fault; for (fault = 2; fault <= 4; ++fault) { initial_values(); open_fixture(&one, P_ACK, 15000); one.send_fault = (int)fault; send_request(111, 6, 5002, 200, 1); CHECK(execute() == IEC104_PARAMETER_EXECUTE_OK); read_events(); status(); CHECK(one.status.finish_pending && one.status.pending_requests == 1); CHECK(!IEC104_Parameter_Destroy(one.module)); CHECK(execute() == IEC104_PARAMETER_EXECUTE_OK); CHECK(one.aborts == 1 && one.commits == 0 && values[1].scaled == 100); close_fixture(&one); } ++groups; } /** * 功能:验证以下场景与约束:[ACK 串行与调度] 前序准备未收尾时,后续动作和带运行值确认都被阻挡。 * 输入参数:无。 * 输出参数:无。 * 返回值:无。 * 说明:后续执行期限仍照常到期。等待期间 execute_ready/need_process 不制造忙循环。 */ static void test_ack_blocking(void) { #if IEC104_PARAMETER_TASK_CAPACITY >= 4 unsigned commit, test; for (commit = 0; commit < 2; ++commit) for (test = 0; test < 2; ++test) { initial_values(); open_fixture(&one, P_ACK, 10); send_request(111, 6, 5002, 200, 1); CHECK(execute() == IEC104_PARAMETER_EXECUTE_OK); flush(); send_request(111, test ? 0x86 : 6, 5002, 300, 1); status(); CHECK(one.status.execute_pending == !test && !one.status.execute_ready); CHECK(!one.status.need_process && one.status.ack_pending); CHECK(execute() == IEC104_PARAMETER_EXECUTE_EMPTY && one.calls == 1); if (!test) { fake.now = 1010; CHECK(IEC104_Parameter_Process(one.module)); status(); CHECK(one.status.timeouts == 1); } if (commit) { ack_all(); } else { one.ack_error = 1; CHECK(IEC104_Parameter_Process(one.module)); } CHECK(execute() == IEC104_PARAMETER_EXECUTE_OK); flush(); expect_reply(1, 111, test ? 0x87 : 0x47, 1, 5002, commit ? 200 : 100, 1); CHECK(one.calls == 2); close_fixture(&one); } /* 镜像确认不等候选值生效,但不能越过更早一份等待取运行值的确认。 */ initial_values(); open_fixture(&one, P_ACK, 15000); send_request(111, 6, 5002, 200, 1); CHECK(execute() == IEC104_PARAMETER_EXECUTE_OK); flush(); send_request(111, 8, 5002, 333, 1); flush(); expect_reply(1, 111, 0x6D, 1, 5002, 333, 1); CHECK(one.status.ack_pending && one.calls == 1); send_request(111, 0x86, 5002, 444, 1); send_request(111, 6, 999, 555, 1); flush(); CHECK(one.status.submitted == 2 && !one.status.need_process); ack_all(); CHECK(execute() == IEC104_PARAMETER_EXECUTE_OK); flush(); expect_reply(2, 111, 0x87, 1, 5002, 200, 1); expect_reply(3, 111, 0x6F, 1, 999, 555, 1); close_fixture(&one); #else puts("SKIP ACK blocked successor: task capacity < 4"); #endif ++groups; } /** * 功能:验证以下场景与约束:[STAGED 提交门槛] 先 ACK,再制造尚未分派的 STOP/STOP+START、删站/同 CA * 重注册或 Cancel。 * 输入参数:无。 * 输出参数:无。 * 返回值:无。 * 说明:旧暂存均须 ABORT;只看最终 active 或 CA 会漏掉这些边界。 */ static void test_staged_commit_gate(void) { unsigned mode; for (mode = 0; mode < 5; ++mode) { IEC104_Station_t replacement = {0}; initial_values(); open_fixture(&one, P_ACK | IEC104_PARAMETER_EXT_QPA_LOADED, 15000); one.result = P_STAGED; send_request(111, 6, 5002, 200, 1); CHECK(execute() == IEC104_PARAMETER_EXECUTE_OK); flush(); ack_all(); CHECK(one.status.finish_pending); if (mode < 2) { push(stop_act, sizeof(stop_act)); if (mode == 1) { push(start_act, sizeof(start_act)); } CHECK(IEC104_Slave_Poll(one.slave, 0, NULL) == IEC104_TCP_OK); CHECK(execute() == IEC104_PARAMETER_EXECUTE_WAIT && one.commits == 0); read_events(); } else if (mode == 2 || mode == 4) { CHECK(IEC104_Slave_Remove_Station(one.slave, &one.station) == IEC104_STATION_OK); if (mode == 4) { CHECK(IEC104_Slave_Add_Station(one.slave, &replacement, 1, &one) == IEC104_STATION_OK); CHECK(IEC104_Station_Get_Id(&replacement) != one.prepared.station_id); } } else { IEC104_Parameter_Cancel(one.module); } CHECK(execute() == IEC104_PARAMETER_EXECUTE_OK && one.aborts == 1 && one.commits == 0); if (mode == 4) { CHECK(IEC104_Slave_Remove_Station(one.slave, &replacement) == IEC104_STATION_OK); } close_fixture(&one); } /* APPLIED 已被 ACK 的提交不依赖会话,未读 STOP 不能阻止它兑现运行值。 */ initial_values(); open_fixture(&one, P_ACK, 15000); send_request(111, 6, 5002, 200, 1); CHECK(execute() == IEC104_PARAMETER_EXECUTE_OK); flush(); ack_all(); push(stop_act, sizeof(stop_act)); CHECK(IEC104_Slave_Poll(one.slave, 0, NULL) == IEC104_TCP_OK); CHECK(execute() == IEC104_PARAMETER_EXECUTE_OK && one.commits == 1); read_events(); close_fixture(&one); ++groups; } /** * 功能:验证以下场景与约束:[会话寿命] 断线清除会话暂存,重连改变 generation 而保留模块 instance_id。 * 输入参数:无。 * 输出参数:无。 * 返回值:无。 * 说明:旧事件不得重新受理。Destroy 失败时对象还在使用,应用不能提前清掉暂存。 */ static void test_session_identity_and_destroy(void) { unsigned mode; for (mode = 0; mode < 3; ++mode) { IEC104_SlaveEvent_t original; uint64_t generation, instance_id = 0; initial_values(); open_fixture(&one, (uint8_t)(IEC104_PARAMETER_EXT_QPA_LOADED | (mode == 1 ? P_ACK : 0)), 15000); send_request(111, 6, 5002, 200, 1); CHECK(IEC104_Slave_Copy_Event(&original, &one.input)); status(); generation = one.status.generation; if (mode != 0) { one.result = mode == 2 ? P_STAGED : P_APPLIED; CHECK(execute() == IEC104_PARAMETER_EXECUTE_OK); flush(); instance_id = one.last.instance_id; } if (mode == 2) { CHECK(one.staged_valid); send_request(113, 6, 0, 0, 1); CHECK(!IEC104_Parameter_Destroy(one.module) && one.staged_valid); } fake.recv_eof = 1; poll_parameter(); fake.recv_eof = 0; status(); CHECK(one.status.generation == 0 && !one.status.active && !one.staged_valid); if (mode == 1) { CHECK(execute() == IEC104_PARAMETER_EXECUTE_OK && one.aborts == 1); } status(); CHECK(one.status.pending_requests == 0 && one.status.cancelled == (mode != 1)); one.ns = one.nr = 0; fake.sent_bytes = 0; fake.accept_pending = 1; poll_parameter(); push(start_act, sizeof(start_act)); poll_parameter(); status(); CHECK(one.status.active && one.status.generation != generation); CHECK(IEC104_Parameter_Handle_Event(one.module, &original) == IEC104_PARAMETER_EVENT_IGNORED); one.result = P_APPLIED; send_request(113, 0x86, 5001, 0, 3); CHECK(execute() == IEC104_PARAMETER_EXECUTE_OK); flush(); if (instance_id != 0) { CHECK(one.last.instance_id == instance_id); } CHECK(one.last.generation == one.status.generation); close_fixture(&one); } ++groups; } /** * 功能:验证以下场景与约束:[分派边界] 未知/关闭的类型和不可用视图保持 IGNORED。 * 输入参数:无。 * 输出参数:无。 * 返回值:无。 * 说明:已知类型的截短帧由 * Receiver 终止链路,模块没有收到请求,不能误增自身 rejected 计数。 */ static void test_filters_and_truncation(void) { IEC104_SlaveEvent_t copy; uint8_t bytes[32]; size_t n; initial_values(); open_fixture(&one, 0, 15000); n = request_bytes(bytes, 200, 6, 1, 5002, 200, 1); queue_bytes(bytes, n); poll_parameter(); status(); CHECK(one.handled == IEC104_PARAMETER_EVENT_IGNORED && one.status.accepted == 0); send_request(111, 6, 5002, 200, 1); CHECK(IEC104_Slave_Copy_Event(©, &one.input)); copy.asdu_result = IEC60870_ASDU_ERROR; CHECK(IEC104_Parameter_Handle_Event(one.module, ©) == IEC104_PARAMETER_EVENT_IGNORED); IEC104_Parameter_Cancel(one.module); n = request_bytes(bytes, 112, 6, 1, 5003, 0x40000000, 2); queue_bytes(bytes, n - 1U); /* 在 I_FRAME 交付之前断链,随后只分派生命周期通知。 */ (void)IEC104_Slave_Poll(one.slave, 0, NULL); read_events(); status(); CHECK(one.status.accepted == 1 && one.status.rejected == 0 && !one.status.active); close_fixture(&one); initial_values(); open_fixture_config(&one, 0, 15000, 10, IEC104_PARAMETER_TYPE_BIT(113)); send_request(111, 6, 5002, 200, 1); status(); CHECK(one.handled == IEC104_PARAMETER_EVENT_IGNORED && one.status.accepted == 0); CHECK(IEC104_Slave_Copy_Event(©, &one.input)); push(stop_act, sizeof(stop_act)); poll_parameter(); CHECK(IEC104_Parameter_Handle_Event(one.module, ©) == IEC104_PARAMETER_EVENT_IGNORED); close_fixture(&one); ++groups; } /** * 功能:验证以下场景与约束:[真实观察槽背压] 直接占满 Slave 的 ACK 观察槽,不用故障钩子伪造 WAIT。 * 输入参数:无。 * 输出参数:无。 * 返回值:无。 * 说明:释放后同一准备重试成功,再经真实 S 帧 ACK 完成一次 COMMIT。 */ static void test_real_ack_capacity(void) { IEC104_SlaveAckReceipt_t receipts[IEC104_TCP_ACK_WATCH_CAPACITY]; IEC104_SlaveEventIdentity_t identity; IEC60870_Asdu_t response; uint8_t bytes[32]; size_t n; unsigned i; initial_values(); open_fixture(&one, P_ACK, 15000); send_request(111, 6, 5002, 200, 1); CHECK(IEC104_Slave_Get_Event_Identity(one.slave, &one.input, &identity)); n = request_bytes(bytes, 111, 7, 1, 5002, 100, 1); CHECK(IEC60870_Asdu_Create_From_Buffer(&response, IEC104_Slave_Get_Application_Layer_Parameters(one.slave), bytes, (uint16_t)n) == IEC60870_ASDU_OK); for (i = 0; i < IEC104_TCP_ACK_WATCH_CAPACITY; ++i) { CHECK(IEC104_Slave_Send_Response_Acked(one.slave, &identity, &response, &receipts[i]) == IEC104_TCP_SUBMIT_OK); poll_parameter(); } CHECK(execute() == IEC104_PARAMETER_EXECUTE_OK); status(); CHECK(one.status.waits == 1 && !one.status.ack_pending && one.status.confirm_pending); for (i = 0; i < IEC104_TCP_ACK_WATCH_CAPACITY; ++i) { IEC104_Slave_Release_Ack(one.slave, &receipts[i]); } flush(); CHECK(one.status.ack_pending); ack_all(); CHECK(execute() == IEC104_PARAMETER_EXECUTE_OK); CHECK(one.commits == 1 && values[1].scaled == 200); close_fixture(&one); ++groups; } #if IEC104_TCP_SERVER_CAPACITY > 1 /* [应用预留] owners 独立于模块存储。A/B 是两个约束组,上下限共用 B; * QPA=1 场景只演练同时取得 A/B 的预留,激活快照的实际应用另在 edge 测试覆盖。 * 肯定 PREPARE 持有预留到收尾;否定 PREPARE 没有 ABORT,须在返回前自行释放。 */ static uint64_t owners[2]; /** * 功能:按约束组预留准备资源并检查上下限。 * 输入参数:context——业务回调的测试上下文;request——当前业务请求(只读)。 * 输出参数:无。 * 返回值:业务动作结果,保留应用成功、业务拒绝及未知对象等协议区别。 * 说明:冲突释放本次部分预留,COMMIT/ABORT释放全部持有项。 */ static IEC104_ParameterActionResult_t reserved_action(void *context, const IEC104_ParameterRequest_t *request) { ParameterFixture *f = context; IEC104_ParameterActionResult_t result; unsigned first = request->operation == IEC104_PARAMETER_OP_LOAD && request->point_index >= 3 ? 1U : 0U; unsigned last = request->operation == IEC104_PARAMETER_OP_LOAD ? first : 1U; unsigned group; if (request->phase == IEC104_PARAMETER_PHASE_COMMIT || request->phase == IEC104_PARAMETER_PHASE_ABORT) { result = action(context, request); for (group = first; group <= last; ++group) { CHECK(owners[group] == request->instance_id); owners[group] = 0; } return result; } f->result = P_APPLIED; for (group = first; group <= last; ++group) { if (owners[group] != 0 && owners[group] != request->instance_id) { /* 取得 A 后在 B 冲突,释放本次取得的 A;不能动另一实例持有的 B。 */ unsigned acquired; for (acquired = first; acquired < group; ++acquired) { CHECK(owners[acquired] == request->instance_id); owners[acquired] = 0; } f->result = P_REJECTED; break; } if (request->phase == IEC104_PARAMETER_PHASE_PREPARE) { owners[group] = request->instance_id; } } if (f->result == P_APPLIED && request->operation == IEC104_PARAMETER_OP_LOAD && ((request->point_index == 3 && request->value.scaled > values[4].scaled) || (request->point_index == 4 && request->value.scaled < values[3].scaled))) { if (request->phase == IEC104_PARAMETER_PHASE_PREPARE) { owners[first] = 0; } f->result = P_REJECTED; } return action(context, request); } /** * 功能:使用带约束组预留的动作执行一次任务,并断言本次已完成动作或收尾交付。 * 输入参数:无。 * 输出参数:无。 * 返回值:无。 * 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。 */ static void reserve_execute(void) { CHECK(IEC104_Parameter_Execute_Next(current->module, reserved_action, current) == IEC104_PARAMETER_EXECUTE_OK); } #endif /** * 功能:验证以下场景与约束:[跨实例取值] 两个实例串行共享数组,只保证读取时一致。 * 输入参数:无。 * 输出参数:无。 * 返回值:无。 * 说明:A 已固定的旧确认 * 不因 B 写入而刷新,A 随后新形成的确认才应读到 B 的新值。 */ static void test_cross_instance_values(void) { #if IEC104_TCP_SERVER_CAPACITY > 1 initial_values(); open_fixture(&one, 0, 15000); open_fixture(&two, 0, 15000); select_fixture(&one); one.send_fault = 1; send_request(111, 0x86, 5002, 999, 1); CHECK(IEC104_Parameter_Process(one.module)); select_fixture(&two); send_request(111, 6, 5002, 200, 1); CHECK(execute() == IEC104_PARAMETER_EXECUTE_OK); flush(); select_fixture(&one); one.send_fault = 0; flush(); expect_reply(0, 111, 0x87, 1, 5002, 100, 1); send_request(111, 0x86, 5002, 999, 1); flush(); expect_reply(1, 111, 0x87, 1, 5002, 200, 1); close_fixture(&one); close_fixture(&two); #else puts("SKIP cross-instance confirmation values: TCP capacity < 2"); #endif ++groups; } /** * 功能:验证以下场景与约束:[跨实例约束] A 准备上限 200 时 B 的下限 150 被预留阻挡。 * 输入参数:无。 * 输出参数:无。 * 返回值:无。 * 说明:A 提交/放弃后 B * 重试分别通过/拒绝。B 使用 ACK 和默认模式都须遵守同一应用预留。 */ static void test_cross_instance_reservations(void) { #if IEC104_TCP_SERVER_CAPACITY > 1 unsigned commit, normal; for (normal = 0; normal < 2; ++normal) for (commit = 0; commit < 2; ++commit) { memset(owners, 0, sizeof(owners)); initial_values(); open_fixture(&one, P_ACK, 15000); open_fixture(&two, normal ? 0 : P_ACK, 15000); select_fixture(&one); send_request(111, 6, 5005, 200, 4); reserve_execute(); flush(); CHECK(owners[1] != 0); select_fixture(&two); send_request(111, 6, 5004, 150, 3); reserve_execute(); flush(); expect_reply(0, 111, 0x47, 1, 5004, 0, 3); CHECK(values[3].scaled == 0); select_fixture(&one); if (commit) { ack_all(); } else { IEC104_Parameter_Cancel(one.module); } reserve_execute(); CHECK(owners[1] == 0); select_fixture(&two); send_request(111, 6, 5004, 150, 3); reserve_execute(); flush(); expect_reply(1, 111, commit ? 7 : 0x47, 1, 5004, commit ? 150 : 0, 3); if (commit && !normal) { ack_all(); reserve_execute(); } CHECK(values[3].scaled <= values[4].scaled && owners[1] == 0); close_fixture(&two); close_fixture(&one); } /* 多组准备在 B 冲突返回否定后,另一实例仍能取得 A,证明部分预留已释放。 * 先完成该实例原先 B 的收尾,再发新请求,避免被实例内串行屏障掩盖结果。 */ memset(owners, 0, sizeof(owners)); initial_values(); open_fixture(&one, P_ACK | IEC104_PARAMETER_EXT_QPA_LOADED, 15000); open_fixture(&two, P_ACK | IEC104_PARAMETER_EXT_QPA_LOADED, 15000); send_request(111, 6, 5005, 200, 4); reserve_execute(); flush(); select_fixture(&one); send_request(113, 6, 0, 0, 1); reserve_execute(); flush(); expect_reply(0, 113, 0x47, 1, 0, 0, 1); CHECK(owners[0] == 0 && owners[1] != 0); CHECK(one.commits == 0 && one.aborts == 0 && execute() == IEC104_PARAMETER_EXECUTE_EMPTY); select_fixture(&two); ack_all(); reserve_execute(); send_request(111, 6, 5002, 200, 1); reserve_execute(); flush(); expect_reply(1, 111, 7, 1, 5002, 200, 1); ack_all(); reserve_execute(); CHECK(owners[0] == 0 && owners[1] == 0); close_fixture(&two); close_fixture(&one); #else puts("SKIP D-40/D-44 reservations: TCP capacity < 2"); #endif ++groups; } /** * 功能:运行参数编解码、执行/ACK期限、收尾和跨实例共享用例,并报告容量矩阵与结构尺寸。 * 输入参数:无。 * 输出参数:无。 * 返回值:正常完成返回 0;参数、运行或断言失败以非零状态结束进程。 * 说明:本辅助入口用于构造或核对上述测试场景,相关状态保存在当前测试夹具中。 */ int main(void) { test_configuration(); test_load_results(); test_validation(); test_float_bits(); test_test_bit(); test_deadlines_and_retry(); test_fifo(); test_overload_and_lifetime(); test_extensions(); test_ack_success_and_loss(); test_prepare_timeout(); test_prepare_clock_and_disabled_deadline(); test_ack_submission_faults(); test_ack_blocking(); test_staged_commit_gate(); test_session_identity_and_destroy(); test_filters_and_truncation(); test_real_ack_capacity(); test_cross_instance_values(); test_cross_instance_reservations(); printf("Parameter: %u groups passed; TCP=%u tasks=%u request=%zu status=%zu point=%zu value=%zu\n", groups, (unsigned)IEC104_TCP_SERVER_CAPACITY, (unsigned)IEC104_PARAMETER_TASK_CAPACITY, sizeof(IEC104_ParameterRequest_t), sizeof(IEC104_ParameterStatus_t), sizeof(IEC104_ParameterPoint_t), sizeof(IEC104_ParameterValue_t)); return 0; }