/* State Grid Type 200..203: independent wire vectors and deterministic faults. * This fixture uses real Slave/TCP/queue code with the shared memory Net backend. * Run at TCP capacity 1/2 and task capacity 1/2/4, with HIGH=251. */ #include "iec104_test_config.h" #include "iec104_tcp_fixture.h" #include "IEC104_RemoteParameter.h" #ifndef IEC104_REMOTE_PARAMETER_TASK_CAPACITY #define IEC104_REMOTE_PARAMETER_TASK_CAPACITY 2U #endif typedef struct { IEC104_Slave_t *slave; IEC104_RemoteParameter_t *module; IEC104_Station_t stations[3]; IEC104_RemoteParameterRequest_t last, first; IEC104_SlaveEvent_t input; IEC104_RemoteParameterEventResult_t handled; IEC104_RemoteParameterConfig_t config; unsigned ns, nr, calls[8], lookups, sends, closes; unsigned lookup_mode, rows, width, value, bad_index; unsigned send_fault, query_fault, check_fault, close_fault; unsigned action_mode, current, staged_sn, staged_value; bool staged, checked_fields; IEC104_RemoteParameterActionResult_t result; IEC104_SlaveEventIdentity_t closed_identity, sent_identity; } fixture_t; static fixture_t rp; static unsigned groups; static const uint8_t switch1[] = {200,1,6,17,1,0,0,0,0,1,0}; static const uint8_t area1[] = {201,1,6,17,1,0,0,0,0}; static const uint8_t read1[] = {202,1,6,17,1,0,1,0,1,128,0}; static const uint8_t read_all[] = {202,0,6,17,1,0,1,0}; static const uint8_t preset1[] = {203,1,6,17,1,0,1,0,128,1,128,0,45,2,100,0}; static const uint8_t solidify1[] = {203,0,6,17,1,0,1,0,0}; static const uint8_t cancel1[] = {203,0,8,17,1,0,1,0,0}; /** * 功能:返回可由用例直接推进或回退的模拟时钟,使各类期限检查保持确定性。 * 输入参数:无。 * 输出参数:无。 * 返回值:本次采样的时钟毫秒值。 * 说明:与宿主墙钟无关的测试路径使用夹具时基;时间推进方式由当前用例控制。 */ uint64_t IEC104_RemoteParameter_Test_Now_Ms(void) { return fake.now; } /** * 功能:按开关注入请求身份检查失败,其余情况使用真实 Slave 的请求有效性判断。 * 输入参数:slave——被测 Slave 实例(只读);identity——请求所属的 Slave、实例及连接代次身份(只读)。 * 输出参数:无。 * 返回值:请求身份的可执行、待事件、过期或错误状态。 * 说明:本辅助入口用于构造或核对上述测试场景,相关状态保存在当前测试夹具中。 */ IEC104_SlaveRequestState_t IEC104_RemoteParameter_Test_Check_Request( const IEC104_Slave_t *slave, const IEC104_SlaveEventIdentity_t *identity) { if (rp.check_fault != 0U) return IEC104_SLAVE_REQUEST_ERROR; return IEC104_Slave_Check_Request(slave, identity); } /** * 功能:为底层连接状态查询注入错误,正常路径保留 Slave 实际状态。 * 输入参数:slave——被测 Slave 实例(只读);status——状态快照;error——底层错误码存储。 * 输出参数:status——状态快照;error——底层错误码存储。 * 返回值:真实传输接口或故障注入产生的 TCP 操作结果。 * 说明:本辅助入口用于构造或核对上述测试场景,相关状态保存在当前测试夹具中。 */ IEC104_TcpResult_t IEC104_RemoteParameter_Test_Get_Status(const IEC104_Slave_t *slave, IEC104_TcpServerStatus_t *status, IEC104_TcpError_t *error) { if (rp.query_fault != 0U) return IEC104_TCP_INTERNAL_ERROR; return IEC104_Slave_Get_Status(slave, status, error); } /** * 功能:记录提交次数及请求身份,注入 WAIT、ERROR、FATAL 或发送期间的未分派 STOP。 * 输入参数:slave——被测 Slave 实例;identity——请求所属的 Slave、实例及连接代次身份(只读);response——响应 ASDU(只读)。 * 输出参数:无。 * 返回值:发送提交结果,区分接收成功、WAIT、ERROR 与 FATAL。 * 说明:正常路径提交真实响应。 */ IEC104_TcpSubmitResult_t IEC104_RemoteParameter_Test_Send_Response(IEC104_Slave_t *slave, const IEC104_SlaveEventIdentity_t *identity, const IEC60870_Asdu_t *response) { ++rp.sends; rp.sent_identity = *identity; if (rp.send_fault == 1U) return IEC104_TCP_SUBMIT_WAIT; if (rp.send_fault == 2U) return IEC104_TCP_SUBMIT_ERROR; if (rp.send_fault == 3U) return IEC104_TCP_SUBMIT_FATAL; if (rp.send_fault == 4U || rp.send_fault == 5U) { push(stop_act, sizeof(stop_act)); CHECK(IEC104_Slave_Poll(slave, 0, NULL) == IEC104_TCP_OK); return rp.send_fault == 4U ? IEC104_TCP_SUBMIT_ERROR : IEC104_TCP_SUBMIT_FATAL; } return IEC104_Slave_Send_Response(slave, identity, response); } /** * 功能:记录关链次数和身份,按需模拟关闭失败,否则调用按身份关闭连接的真实接口。 * 输入参数:slave——被测 Slave 实例;identity——请求所属的 Slave、实例及连接代次身份(只读);error——底层错误码存储。 * 输出参数:error——底层错误码存储。 * 返回值:真实传输接口或故障注入产生的 TCP 操作结果。 * 说明:本辅助入口用于构造或核对上述测试场景,相关状态保存在当前测试夹具中。 */ IEC104_TcpResult_t IEC104_RemoteParameter_Test_Close_Connection(IEC104_Slave_t *slave, const IEC104_SlaveEventIdentity_t *identity, IEC104_TcpError_t *error) { ++rp.closes; rp.closed_identity = *identity; if (rp.close_fault != 0U) return IEC104_TCP_INTERNAL_ERROR; return IEC104_Slave_Close_Connection_By_Identity(slave, identity, error); } /** * 功能:获取遥调模块的状态副本,查询失败立即终止用例。 * 输入参数:无。 * 输出参数:无。 * 返回值:按值返回的当前状态或信息快照。 * 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。 */ static IEC104_RemoteParameterStatus_t status(void) { IEC104_RemoteParameterStatus_t state; CHECK(IEC104_RemoteParameter_Get_Status(rp.module, &state)); return state; } /** * 功能:排空并分派 Slave 事件,保存最近 I 帧及其处理结果,供回调身份与接收状态断言使用。 * 输入参数:无。 * 输出参数:无。 * 返回值:无。 * 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。 */ static void events(void) { IEC104_SlaveEvent_t event; IEC104_TcpEventResult_t next; while ((next = IEC104_Slave_NextEvent(rp.slave, &event)) == IEC104_TCP_EVENT_READY) { IEC104_RemoteParameterEventResult_t result = IEC104_RemoteParameter_Handle_Event(rp.module, &event); CHECK(result != IEC104_REMOTE_PARAMETER_EVENT_ERROR); if (event.transport.type == IEC104_TCP_EVENT_I_FRAME) { CHECK(IEC104_Slave_Copy_Event(&rp.input, &event)); rp.handled = result; } } CHECK(next == IEC104_TCP_EVENT_EMPTY); } /** * 功能:轮询一次真实 Slave 传输层,再将产生的事件交给遥调模块。 * 输入参数:无。 * 输出参数:无。 * 返回值:无。 * 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。 */ static void poll_rp(void) { CHECK(IEC104_Slave_Poll(rp.slave, 0, NULL) == IEC104_TCP_OK); events(); } /** * 功能:交替轮询和处理模块六轮,推进已有确认发送而不执行新的业务回调。 * 输入参数:无。 * 输出参数:无。 * 返回值:无。 * 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。 */ static void flush(void) { unsigned i; for (i = 0; i < 6U; ++i) { poll_rp(); CHECK(IEC104_RemoteParameter_Process(rp.module)); } } /** * 功能:解析模拟网络输出,收集 I 帧 ASDU 的借用指针及长度,并推进夹具的接收确认号。 * 输入参数:frames——按线上顺序排列的 ASDU 视图数组;lengths——各 ASDU 的长度数组。 * 输出参数:frames——按线上顺序排列的 ASDU 视图数组;lengths——各 ASDU 的长度数组。 * 返回值:本次收集或统计到的有效业务帧数量。 * 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。 */ static unsigned collect(const uint8_t **frames, size_t *lengths) { size_t offset = 0; unsigned count = 0; while (offset < fake.sent_bytes) { const uint8_t *frame = fake.output + offset; size_t length = (size_t)frame[1] + 2U; CHECK(length >= 6U && offset + length <= fake.sent_bytes); if ((frame[2] & 1U) == 0U) { CHECK(count < 128U); frames[count] = frame + 6; lengths[count++] = length - 6; rp.nr = (((unsigned)frame[2] >> 1) | ((unsigned)frame[3] << 7)) + 1U; } offset += length; } return count; } /** * 功能:确认当前已发送的 I 帧并清空输出记录,为下一次报文比对建立起点。 * 输入参数:无。 * 输出参数:无。 * 返回值:无。 * 说明:接口保留参数仍按回调签名传入,未使用的参数不参与本辅助函数的处理。 */ static void clear_wire(void) { const uint8_t *frames[128]; size_t lengths[128]; (void)collect(frames, lengths); push_ack(rp.nr); poll_rp(); fake.sent_bytes = 0; } /** * 功能:核对指定 I 帧 ASDU 的长度与全部字节,不匹配时打印实际报文并终止测试。 * 输入参数:index——待访问或核对的条目下标;bytes——报文字节缓冲区(只读);size——数据长度或文件大小。 * 输出参数:无。 * 返回值:无。 * 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。 */ static void expect(unsigned index, const uint8_t *bytes, size_t size) { const uint8_t *frames[128]; size_t lengths[128]; CHECK(collect(frames, lengths) > index); if (lengths[index] != size || memcmp(frames[index], bytes, size) != 0) { size_t i; fprintf(stderr, "wire group=%u index=%u length=%zu expected=%zu actual:", groups,index,lengths[index],size); for (i = 0; i < lengths[index]; ++i) fprintf(stderr," %02X",frames[index][i]); fprintf(stderr,"\n"); CHECK(false); } } /** * 功能:将 ASDU 按当前收发序号封装为 I 帧并注入输入缓冲区,暂不轮询,便于构造批量请求。 * 输入参数:bytes——报文字节缓冲区(只读);size——数据长度或文件大小。 * 输出参数:无。 * 返回值:无。 * 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。 */ static void queue(const uint8_t *bytes, size_t size) { uint8_t frame[255] = {0x68}; CHECK(size <= 249U); frame[1] = (uint8_t)(size + 4U); frame[2] = (uint8_t)(rp.ns << 1); frame[3] = (uint8_t)(rp.ns >> 7); ++rp.ns; frame[4] = (uint8_t)(rp.nr << 1); frame[5] = (uint8_t)(rp.nr >> 7); memcpy(frame + 6, bytes, size); push(frame, size + 6U); } /** * 功能:注入单条遥调请求并立即轮询、分派接收事件。 * 输入参数:bytes——报文字节缓冲区(只读);size——数据长度或文件大小。 * 输出参数:无。 * 返回值:无。 * 说明:本辅助入口用于构造或核对上述测试场景,相关状态保存在当前测试夹具中。 */ static void send_rp(const uint8_t *bytes, size_t size) { queue(bytes,size); poll_rp(); } /** * 功能:模拟定值区切换、预置、固化及清理,核对各操作字段和预置元素的有效期。 * 输入参数:context——业务回调的测试上下文;request——当前业务请求(只读);area——定值区范围及当前区号。 * 输出参数:area——读区操作返回的当前区、最小区及最大区。 * 返回值:业务动作结果,保留应用成功、业务拒绝及未知对象等协议区别。 * 说明:可注入业务拒绝、重入、时钟推进及回调后故障,DISCARD 按首帧身份撤销暂存值。 */ static IEC104_RemoteParameterActionResult_t action(void *context, const IEC104_RemoteParameterRequest_t *request, IEC104_RemoteParameterArea_t *area) { IEC104_RemoteParameterElement_t element; IEC104_RemoteParameterStatus_t state = status(); CHECK(context == &rp && request->operation >= 1 && request->operation <= 7); CHECK(!state.execute_ready); CHECK(request->identity.slave == rp.slave && request->generation == request->identity.generation); CHECK(request->station_id != 0U && request->instance_id != 0U); CHECK(!request->test || request->operation == IEC104_REMOTE_PARAMETER_OP_READ_AREA); ++rp.calls[request->operation]; rp.last = *request; if (request->operation != IEC104_REMOTE_PARAMETER_OP_PRESET) { CHECK(request->count == 0 && !request->first_frame && !request->more_follows); CHECK(request->_data == NULL && request->_length == 0); CHECK(!IEC104_RemoteParameter_Get_Element(request,0,&element)); } else { size_t i; CHECK(area == NULL && request->count > 0); CHECK(!IEC104_RemoteParameter_Get_Element(request,request->count,&element)); for (i = 0; i < request->count; ++i) { CHECK(IEC104_RemoteParameter_Get_Element(request,i,&element)); CHECK(element.ioa > 0); if (i == 0 && element.length > 0) rp.staged_value = element.value[0]; } if (request->first_frame) rp.first = *request; } if (request->operation == IEC104_REMOTE_PARAMETER_OP_DISCARD) { CHECK(request->sn == rp.first.sn && request->station_id == rp.first.station_id); CHECK(request->receive_serial == rp.first.receive_serial && request->accepted_ms == rp.first.accepted_ms); rp.staged = false; return IEC104_REMOTE_PARAMETER_ACTION_REJECTED; } CHECK(request->receive_serial == rp.input.transport.data.i_frame.receive_serial || rp.checked_fields); if (request->operation == IEC104_REMOTE_PARAMETER_OP_READ_AREA) { CHECK(area != NULL && area->current == 0 && area->minimum == 0 && area->maximum == 0); CHECK(request->sn == 0); area->minimum = 0; area->current = (uint16_t)rp.current; area->maximum = 4; if (rp.action_mode == 1U) area->minimum = 5; } else CHECK(area == NULL); if (rp.action_mode == 2U) { IEC104_RemoteParameterStatus_t after; CHECK(!IEC104_RemoteParameter_Process(rp.module)); CHECK(!IEC104_RemoteParameter_Destroy(rp.module)); CHECK(IEC104_RemoteParameter_Handle_Event(rp.module,&rp.input) == IEC104_REMOTE_PARAMETER_EVENT_ERROR); CHECK(IEC104_RemoteParameter_Execute_Next(rp.module,NULL,NULL) == IEC104_REMOTE_PARAMETER_EXECUTE_ERROR); IEC104_RemoteParameter_Cancel(rp.module); after = status(); CHECK(after.pending_requests == state.pending_requests); } if (rp.action_mode == 3U) rp.check_fault = 1; if (rp.action_mode == 4U) fake.now += 1000U; if (request->operation == IEC104_REMOTE_PARAMETER_OP_PRESET) { rp.staged = rp.result == IEC104_REMOTE_PARAMETER_ACTION_APPLIED; rp.staged_sn = request->sn; } if (request->operation == IEC104_REMOTE_PARAMETER_OP_SOLIDIFY) { CHECK(rp.staged); if(rp.action_mode==5U&&(rp.bad_index!=0U||rp.staged_value>rp.current)) { rp.staged=false; return IEC104_REMOTE_PARAMETER_ACTION_REJECTED; } if (rp.result == IEC104_REMOTE_PARAMETER_ACTION_APPLIED) rp.value = rp.staged_value; rp.staged = false; } if (request->operation == IEC104_REMOTE_PARAMETER_OP_CANCEL) rp.staged = false; if (request->operation == IEC104_REMOTE_PARAMETER_OP_SWITCH_AREA && rp.result == IEC104_REMOTE_PARAMETER_ACTION_APPLIED) rp.current = request->sn; return rp.result; } /** * 功能:按指定 IOA 或读全量游标生成字节型定值,核对读取回调字段。 * 输入参数:context——业务回调的测试上下文;request——当前业务请求(只读);index——待访问或核对的条目下标;ioa——信息对象地址;frame——读取结果帧或报文缓冲区。 * 输出参数:frame——追加定值元素后的读取帧。 * 返回值:查值结果,区分追加成功、结束/跳过、容量不足及失败。 * 说明:各模式覆盖未知地址、结束、容量不足、违规写帧、异常返回及回调后的状态变化。 */ static IEC104_RemoteParameterLookupResult_t lookup(void *context, const IEC104_RemoteParameterRequest_t *request, size_t index, uint32_t ioa, IEC104_RemoteParameterFrame_t *frame) { uint8_t value[235]; IEC104_RemoteParameterAddResult_t add; CHECK(context == &rp && request->operation == IEC104_REMOTE_PARAMETER_OP_READ); CHECK(!request->first_frame && !request->more_follows && request->_data == NULL && request->_length == 0); CHECK(!status().execute_ready); ++rp.lookups; if (request->count == 0) { CHECK(ioa == 0); ioa = (uint32_t)(0x8001U + index); } if (rp.lookup_mode == 1U) return IEC104_REMOTE_PARAMETER_LOOKUP_UNKNOWN; if (rp.lookup_mode == 2U || (rp.lookup_mode == 12U && index >= rp.bad_index)) return IEC104_REMOTE_PARAMETER_LOOKUP_ERROR; if (rp.lookup_mode == 3U) return IEC104_REMOTE_PARAMETER_LOOKUP_ADDED; if (rp.lookup_mode == 4U) return IEC104_REMOTE_PARAMETER_LOOKUP_FULL; if (rp.lookup_mode == 5U) return IEC104_REMOTE_PARAMETER_LOOKUP_END; if (rp.lookup_mode == 6U) ++ioa; if (request->count == 0 && index >= rp.rows) return IEC104_REMOTE_PARAMETER_LOOKUP_END; memset(value,(int)rp.value,sizeof(value)); if (rp.lookup_mode == 7U) { CHECK(IEC104_RemoteParameter_Add_Element(frame,ioa,99,value,1) == IEC104_REMOTE_PARAMETER_ADD_ERROR); } if(rp.lookup_mode==13U) { CHECK(IEC104_RemoteParameter_Add_Element(NULL,ioa,4,value,1)==IEC104_REMOTE_PARAMETER_ADD_ERROR); (void)IEC104_RemoteParameter_Add_Bytes(frame,ioa,value,1); return IEC104_REMOTE_PARAMETER_LOOKUP_ADDED; } add = IEC104_RemoteParameter_Add_Bytes(frame,ioa,value,(uint8_t)rp.width); if (rp.lookup_mode == 8U) CHECK(IEC104_RemoteParameter_Add_Bytes(frame,ioa,value,1) == IEC104_REMOTE_PARAMETER_ADD_ERROR); if (rp.lookup_mode == 9U) rp.check_fault = 1; if (rp.lookup_mode == 10U) fake.now += 10; if (rp.lookup_mode == 11U) return (IEC104_RemoteParameterLookupResult_t)99; return add == IEC104_REMOTE_PARAMETER_ADD_OK ? IEC104_REMOTE_PARAMETER_LOOKUP_ADDED : IEC104_REMOTE_PARAMETER_LOOKUP_FULL; } static const IEC104_RemoteParameterHandlers_t handlers = {action,lookup}; /** * 功能:使用夹具的动作和查值回调执行一个遥调工作步骤。 * 输入参数:无。 * 输出参数:无。 * 返回值:单步执行结果,区分已执行、无任务、等待及错误。 * 说明:本辅助入口用于构造或核对上述测试场景,相关状态保存在当前测试夹具中。 */ static IEC104_RemoteParameterExecuteResult_t execute(void) { return IEC104_RemoteParameter_Execute_Next(rp.module,&handlers,&rp); } /** * 功能:重置夹具,按确认模式和各类超时建立双站遥调实例,并完成真实连接的 START 握手。 * 输入参数:mode——用例选择的行为模式;execute_ms——执行等待期限(毫秒);preset_ms——预置事务期限(毫秒);read_ms——读取期限(毫秒);reply_ms——确认回复期限(毫秒)。 * 输出参数:无。 * 返回值:无。 * 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。 */ static void open_config(unsigned mode, uint32_t execute_ms, uint32_t preset_ms, uint32_t read_ms, uint32_t reply_ms) { IEC104_SlaveConfig_t config; unsigned i; memset(&rp,0,sizeof(rp)); memset(&fake,0,sizeof(fake)); fake.now = 1000; rp.rows = 5; rp.width = 100; rp.value = 7; rp.result = IEC104_REMOTE_PARAMETER_ACTION_APPLIED; rp.slave = IEC104_Slave_Create(); CHECK(rp.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(rp.slave,&config,NULL) == IEC104_TCP_OK); CHECK(IEC104_Slave_Add_Station(rp.slave,&rp.stations[0],1,&rp) == IEC104_STATION_OK); CHECK(IEC104_Slave_Add_Station(rp.slave,&rp.stations[1],2,&rp) == IEC104_STATION_OK); IEC104_RemoteParameter_Config_Default(&rp.config); rp.config.preset_confirm_mode = (IEC104_RemoteParameterPresetConfirmMode_t)mode; rp.config.execute_timeout_ms = execute_ms; rp.config.preset_timeout_ms = preset_ms; rp.config.read_timeout_ms = read_ms; rp.config.reply_timeout_ms = reply_ms; rp.module = IEC104_RemoteParameter_Create(rp.slave,&rp.config); CHECK(rp.module != NULL); sut = NULL; for (i = 0; i < IEC104_TCP_SERVER_CAPACITY; ++i) if (server_pool[i].in_use) { sut = &server_pool[i].server; break; } CHECK(sut != NULL); fake.accept_pending = 1; poll_rp(); push(start_act,sizeof(start_act)); poll_rp(); CHECK(status().active); fake.sent_bytes = 0; } /** * 功能:使用常规确认模式和默认期限建立已启动的遥调测试连接。 * 输入参数:无。 * 输出参数:无。 * 返回值:无。 * 说明:本辅助入口用于构造或核对上述测试场景,相关状态保存在当前测试夹具中。 */ static void open_rp(void) { open_config(0,15000,60000,60000,15000); } /** * 功能:清除注入故障,取消并关链,执行遗留 DISCARD 后销毁实例和站点,核对暂存值与站点引用均已释放。 * 输入参数:无。 * 输出参数:无。 * 返回值:无。 * 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。 */ static void close_rp(void) { unsigned i; rp.query_fault = rp.check_fault = rp.send_fault = rp.close_fault = 0; IEC104_RemoteParameter_Cancel(rp.module); CHECK(IEC104_Slave_Close(rp.slave,NULL) == IEC104_TCP_OK); events(); if (status().discard_pending) CHECK(execute() == IEC104_REMOTE_PARAMETER_EXECUTE_OK); CHECK(!rp.staged); CHECK(IEC104_RemoteParameter_Destroy(rp.module)); for (i = 0; i < 3U; ++i) { if (IEC104_Station_Is_Registered(&rp.stations[i])) CHECK(IEC104_Slave_Remove_Station(rp.slave,&rp.stations[i]) == IEC104_STATION_OK); CHECK(IEC104_Station_Is_Reusable(&rp.stations[i])); } CHECK(IEC104_Slave_Destroy(rp.slave,NULL) == IEC104_TCP_OK); } /** * 功能:清理旧输出后发送请求、执行一步业务并推进响应,再按独立期望向量核对首帧。 * 输入参数:request——当前业务请求(只读);size——数据长度或文件大小;reply——期望回复原文(只读);reply_size——期望回复长度。 * 输出参数:无。 * 返回值:无。 * 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。 */ static void exchange(const uint8_t *request, size_t size, const uint8_t *reply, size_t reply_size) { clear_wire(); send_rp(request,size); CHECK(execute() != IEC104_REMOTE_PARAMETER_EXECUTE_ERROR); flush(); expect(0,reply,reply_size); } /** * 功能:以请求镜像生成确认向量,替换传送原因并保留 TEST 位。 * 输入参数:request——当前业务请求(只读);size——数据长度或文件大小;cot——完整传送原因字节。 * 输出参数:无。 * 返回值:无。 * 说明:取消确认同时规范化取消标志。 */ static void mirror(const uint8_t *request, size_t size, uint8_t cot) { uint8_t expected[249]; memcpy(expected,request,size); expected[2] = (uint8_t)((request[2]&128U)|cot); if (request[0] == 203U && request[2] % 64U == 8U && size == 9U && (request[8] == 0 || request[8] == 64U)) expected[8] = 64; exchange(request,size,expected,size); } /** * 功能:发送普通取消并核对成功确认,断言当前恢复门禁已解除。 * 输入参数:无。 * 输出参数:无。 * 返回值:无。 * 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。 */ static void recover(void) { mirror(cancel1,sizeof(cancel1),9); CHECK(!status().recovery_required); } /** * 功能:核对默认配置、非法配置及重复实例的拒绝,缺失动作回调时待办请求保持不变且不产生业务副作用。 * 输入参数:无。 * 输出参数:无。 * 返回值:无。 * 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。 */ static void test_configuration(void) { IEC104_RemoteParameterConfig_t config; IEC104_SlaveConfig_t transport; IEC104_RemoteParameterHandlers_t missing = {NULL,lookup}; IEC104_RemoteParameterStatus_t before; IEC104_RemoteParameter_Config_Default(NULL); IEC104_RemoteParameter_Config_Default(&config); CHECK(config.type_mask == 15 && config.preset_confirm_mode == 0); CHECK(config.execute_timeout_ms == 15000 && config.preset_timeout_ms == 60000); CHECK(config.read_timeout_ms == 60000 && config.reply_timeout_ms == 15000); CHECK(IEC104_RemoteParameter_Create(NULL,&config) == NULL); CHECK(!IEC104_RemoteParameter_Destroy(NULL)); open_rp(); CHECK(IEC104_RemoteParameter_Create(rp.slave,&config) == NULL); CHECK(IEC104_Slave_Close(rp.slave,NULL)==IEC104_TCP_OK);events(); CHECK(IEC104_RemoteParameter_Destroy(rp.module)); rp.module = NULL; config.type_mask = 0; CHECK(IEC104_RemoteParameter_Create(rp.slave,&config) == NULL); config.type_mask = 16; CHECK(IEC104_RemoteParameter_Create(rp.slave,&config) == NULL); config.type_mask = 15; config.preset_confirm_mode = (IEC104_RemoteParameterPresetConfirmMode_t)2; CHECK(IEC104_RemoteParameter_Create(rp.slave,&config) == NULL); IEC104_RemoteParameter_Config_Default(&config); rp.module = IEC104_RemoteParameter_Create(rp.slave,&config); CHECK(rp.module != NULL); test_transport_config(&transport);transport.protocol.link.k=32; CHECK(IEC104_Slave_Init(rp.slave,&transport,NULL)==IEC104_TCP_OK); fake.accept_pending=1;poll_rp();push(start_act,sizeof(start_act));poll_rp(); send_rp(switch1,sizeof(switch1)); before = status(); CHECK(IEC104_RemoteParameter_Execute_Next(rp.module,&missing,&rp) == IEC104_REMOTE_PARAMETER_EXECUTE_ERROR); CHECK(status().pending_requests == before.pending_requests && rp.calls[1] == 0); CHECK(execute() == IEC104_REMOTE_PARAMETER_EXECUTE_OK); flush(); close_rp(); } /** * 功能:覆盖原因、站地址、IOA、对象数和帧长度错误,核对拒绝优先级与预置格式错误后的恢复要求。 * 输入参数:无。 * 输出参数:无。 * 返回值:无。 * 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。 */ static void test_wire_validation(void) { uint8_t bytes[249]; unsigned i; static const struct { unsigned field; uint8_t value, cot; size_t length; } cases[] = { {2,10,109,11},{4,99,110,11},{6,1,111,11},{1,0,71,11}, {1,2,71,11},{1,127,71,11},{1,129,71,11},{2,70,71,11}, {0,200,71,10},{0,200,71,12},{0,200,71,6} }; open_rp(); for (i = 0; i < sizeof(cases)/sizeof(cases[0]); ++i) { memset(bytes,0,sizeof(bytes)); memcpy(bytes,switch1,sizeof(switch1)); bytes[cases[i].field] = cases[i].value; mirror(bytes,cases[i].length,cases[i].cot); } memcpy(bytes,switch1,sizeof(switch1)); bytes[4] = bytes[5] = 255; mirror(bytes,11,110); memcpy(bytes,switch1,sizeof(switch1)); bytes[2]=10; bytes[4]=99; bytes[6]=1; mirror(bytes,11,109); memcpy(bytes,read1,sizeof(read1)); bytes[8]=bytes[9]=bytes[10]=0; mirror(bytes,11,111); memcpy(bytes,read1,sizeof(read1)); mirror(bytes,10,71); mirror(bytes,12,71); memcpy(bytes,preset1,sizeof(preset1)); bytes[8]=130; mirror(bytes,16,71); recover(); CHECK(rp.calls[1] == 0 && rp.calls[4] == 0); close_rp(); } /** * 功能:验证各定值类型的长度与取值约束,包括布尔值、非有限浮点数、负零、非正规数及最大字节串。 * 输入参数:无。 * 输出参数:无。 * 返回值:无。 * 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。 */ static void test_tags(void) { static const uint8_t tags[] = {1,43,32,33,45,2,35,36,37,38,39,4}; static const uint8_t sizes[] = {1,1,1,2,2,4,4,8,8,4,8,0}; unsigned i; uint8_t bytes[249]; open_rp(); for (i=0;i=2U) { queue(bytes,16);bytes[13]=4;queue(bytes,16);poll_rp(); CHECK(rp.calls[4]==0);rp.checked_fields=true; CHECK(execute()==IEC104_REMOTE_PARAMETER_EXECUTE_OK);flush(); } else { mirror(bytes,16,7);bytes[13]=4;send_rp(bytes,16);CHECK(IEC104_RemoteParameter_Process(rp.module)); } CHECK(status().discard_pending&&status().recovery_required); CHECK(execute()==IEC104_REMOTE_PARAMETER_EXECUTE_OK);flush(); CHECK(!rp.staged&&rp.calls[7]==1);recover(); memcpy(bytes,preset1,16);bytes[8]=129;mirror(bytes,16,7); bytes[2]=10;mirror(bytes,16,109);CHECK(status().preset_active); bytes[2]=6;bytes[8]=0;mirror(bytes,16,71);CHECK(status().preset_active); mirror(cancel1,9,9); mirror(preset1,16,7);memcpy(bytes,preset1,16);bytes[13]=4;mirror(bytes,16,71); CHECK(status().preset_active&&!status().recovery_required);mirror(solidify1,9,7); close_rp(); } /** * 功能:验证以下场景与约束:主动取消未执行预置也进入恢复门禁。 * 输入参数:无。 * 输出参数:无。 * 返回值:无。 * 说明:已暂存预置的重复取消只产生一次 DISCARD,普通切区取消无需恢复。 */ static void test_cancel_recovery(void) { unsigned before; open_rp();send_rp(preset1,16);CHECK(rp.calls[4]==0); IEC104_RemoteParameter_Cancel(rp.module); CHECK(status().recovery_required&&!status().discard_pending&&!IEC104_RemoteParameter_Destroy(rp.module)); mirror(preset1,16,71);mirror(solidify1,9,71);recover(); mirror(preset1,16,7);IEC104_RemoteParameter_Cancel(rp.module);IEC104_RemoteParameter_Cancel(rp.module); CHECK(status().discard_pending&&status().recovery_required);before=rp.calls[7]; CHECK(execute()==IEC104_REMOTE_PARAMETER_EXECUTE_OK);CHECK(rp.calls[7]==before+1); CHECK(execute()==IEC104_REMOTE_PARAMETER_EXECUTE_EMPTY);recover(); send_rp(switch1,11);IEC104_RemoteParameter_Cancel(rp.module);CHECK(!status().recovery_required); close_rp(); } /** * 功能:覆盖续帧执行前的预置超时和时钟回退,普通事务清理暂存、TEST 不调业务。 * 输入参数:无。 * 输出参数:无。 * 返回值:无。 * 说明:关闭预置期限后可正常固化,随后确认超时只关链而不撤销已固化数据。 */ static void test_late_preset_deadline(void) { unsigned test_bit, rollback; uint8_t bytes[16]; for(test_bit=0;test_bit<2;++test_bit)for(rollback=0;rollback<2;++rollback) { open_config(0,15000,10,60000,15000); memcpy(bytes,preset1,16);bytes[8]=129;if(test_bit)bytes[2]|=128;mirror(bytes,16,7); bytes[8]=128;send_rp(bytes,16);fake.now=rollback?999:1010; CHECK(execute()==IEC104_REMOTE_PARAMETER_EXECUTE_OK); CHECK(status().recovery_required&&!status().preset_active); CHECK(rp.calls[4]==(test_bit?0U:1U)&&rp.calls[7]==(test_bit?0U:1U)); CHECK(execute()==IEC104_REMOTE_PARAMETER_EXECUTE_OK);CHECK(status().recovery_required); close_rp(); } open_config(0,10,0,0,10);mirror(preset1,16,7);fake.now+=100; send_rp(solidify1,9);rp.send_fault=1;CHECK(execute()==IEC104_REMOTE_PARAMETER_EXECUTE_OK); CHECK(!status().preset_active&&!status().recovery_required&&rp.value==100); fake.now+=10;CHECK(IEC104_RemoteParameter_Process(rp.module)); CHECK(rp.closes==1&&rp.calls[7]==0);events();close_rp(); } /** * 功能:验证以下场景与约束:执行等待超时应在动作回调前拒绝。 * 输入参数:无。 * 输出参数:无。 * 返回值:无。 * 说明:关闭期限允许时钟回退,回调耗时不追溯计为本次等待超时。 */ static void test_execution_deadline(void) { uint8_t reply[11]; open_config(0,10,60000,60000,15000);send_rp(switch1,11);fake.now+=10; CHECK(execute()==IEC104_REMOTE_PARAMETER_EXECUTE_OK);flush();memcpy(reply,switch1,11);reply[2]=71;expect(0,reply,11); CHECK(rp.calls[1]==0&&status().timeouts==1);close_rp(); open_config(0,0,0,0,0);send_rp(switch1,11);fake.now=999; CHECK(execute()==IEC104_REMOTE_PARAMETER_EXECUTE_OK);CHECK(rp.calls[1]==1);close_rp(); open_config(0,10,60000,60000,15000);rp.action_mode=4;send_rp(switch1,11); CHECK(execute()==IEC104_REMOTE_PARAMETER_EXECUTE_OK);CHECK(rp.calls[1]==1&&status().timeouts==0);close_rp(); } /** * 功能:核对全量读取的分页数、条目顺序及后续标志,并覆盖空集合和指定单个 IOA 的响应向量。 * 输入参数:无。 * 输出参数:无。 * 返回值:无。 * 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。 */ static void test_read_stream(void) { const uint8_t *frames[128];size_t lengths[128];unsigned i; open_rp();send_rp(read_all,8); for(i=0;i<3;++i){CHECK(execute()==IEC104_REMOTE_PARAMETER_EXECUTE_OK);flush();} CHECK(collect(frames,lengths)==3); CHECK(lengths[0]==219&&lengths[1]==219&&lengths[2]==114); CHECK(frames[0][1]==2&&frames[0][8]==1&&frames[1][8]==1&&frames[2][8]==0); CHECK(frames[0][9]==1&&frames[1][9]==3&&frames[2][9]==5); CHECK(status().read_frames==3&&status().reads_completed==1&&rp.lookups==8); clear_wire();rp.rows=0;send_rp(read_all,8);CHECK(execute()==IEC104_REMOTE_PARAMETER_EXECUTE_OK);flush(); { const uint8_t empty[]={202,0,7,17,1,0,1,0,0};expect(0,empty,9); } clear_wire();rp.rows=5;rp.width=1;send_rp(read1,11);i=rp.lookups; CHECK(execute()==IEC104_REMOTE_PARAMETER_EXECUTE_OK);flush();CHECK(rp.lookups==i+2); { const uint8_t one[]={202,1,7,17,1,0,1,0,0,1,128,0,4,1,7};expect(0,one,15); } close_rp(); } /** * 功能:验证以下场景与约束:发送 WAIT 后重新查值组帧,恢复时使用最新数据。 * 输入参数:无。 * 输出参数:无。 * 返回值:无。 * 说明:中途失败生成持久终止确认,等待重发不再查值。 */ static void test_read_wait_and_abort(void) { unsigned calls; const uint8_t *frames[128];size_t lengths[128]; open_rp();rp.send_fault=1;send_rp(read_all,8);CHECK(execute()==IEC104_REMOTE_PARAMETER_EXECUTE_WAIT); calls=rp.lookups;CHECK(calls==3&&status().read_frames==0&&!status().execute_ready); rp.value=9;rp.send_fault=0;CHECK(execute()==IEC104_REMOTE_PARAMETER_EXECUTE_OK);flush(); CHECK(rp.lookups==calls+3);CHECK(collect(frames,lengths)==1&&frames[0][14]==9); rp.lookup_mode=2;rp.send_fault=1;CHECK(execute()==IEC104_REMOTE_PARAMETER_EXECUTE_OK); CHECK(status().reads_aborted==1&&status().confirm_pending);calls=rp.lookups; rp.lookup_mode=0;CHECK(IEC104_RemoteParameter_Process(rp.module));CHECK(rp.lookups==calls); rp.send_fault=0;flush();CHECK(collect(frames,lengths)==2); { const uint8_t abort[]={202,0,71,17,1,0,1,0,0};expect(1,abort,9); } CHECK(status().reads_completed==0&&status().reads_aborted==1); close_rp(); } /** * 功能:覆盖查值返回值与实际写帧行为不一致、地址不匹配及非法写入,核对否定确认和回调违规计数。 * 输入参数:无。 * 输出参数:无。 * 返回值:无。 * 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。 */ static void test_lookup_contract(void) { unsigned mode; for(mode=1;mode<=11;++mode) { if(mode==9||mode==10)continue; open_rp();rp.width=1;rp.lookup_mode=mode;mirror(read1,11,mode==1?111:71); CHECK(status().reads_aborted==1&&status().reads_completed==0); if(mode>=3)CHECK(status().invalid_callbacks==1); close_rp(); } open_rp();rp.lookup_mode=1;mirror(read_all,8,71);CHECK(status().invalid_callbacks==1);close_rp(); open_rp();rp.lookup_mode=13;mirror(read1,11,71);CHECK(status().invalid_callbacks==1);close_rp(); } /** * 功能:验证首帧等待及已分页读取的期限终止,终止确认重试不再查值,确认自身超时最终关链。 * 输入参数:无。 * 输出参数:无。 * 返回值:无。 * 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。 */ static void test_read_deadlines(void) { unsigned calls; open_config(0,10,60000,10,10);rp.send_fault=1;send_rp(read_all,8); CHECK(execute()==IEC104_REMOTE_PARAMETER_EXECUTE_WAIT);fake.now+=10; CHECK(execute()==IEC104_REMOTE_PARAMETER_EXECUTE_OK);CHECK(status().timeouts==1&&status().reads_aborted==1); calls=rp.lookups;CHECK(IEC104_RemoteParameter_Process(rp.module));CHECK(rp.lookups==calls); fake.now+=10;CHECK(IEC104_RemoteParameter_Process(rp.module));CHECK(rp.closes==1);events();close_rp(); open_config(0,10,60000,10,15000);send_rp(read_all,8);CHECK(execute()==IEC104_REMOTE_PARAMETER_EXECUTE_OK);flush(); fake.now+=10;CHECK(IEC104_RemoteParameter_Process(rp.module));flush(); CHECK(status().read_timeouts==1&&status().reads_aborted==1&&status().reads_completed==0);close_rp(); } /** * 功能:覆盖发送和身份检查故障,核对待办清空、故障锁定及唯一关链。 * 输入参数:无。 * 输出参数:无。 * 返回值:无。 * 说明:后续请求与 STOP 均不能恢复故障实例。 */ static void test_faults(void) { unsigned fault; for(fault=2;fault<=3;++fault) { open_rp();rp.send_fault=fault;rp.close_fault=1; send_rp(area1,9); if(IEC104_REMOTE_PARAMETER_TASK_CAPACITY>=2U){queue(switch1,11);poll_rp();rp.checked_fields=true;} CHECK(execute()==IEC104_REMOTE_PARAMETER_EXECUTE_OK); CHECK(status().faulted&&status().pending_requests==0&&rp.closes==1&&rp.calls[1]==0); CHECK(!IEC104_RemoteParameter_Destroy(rp.module)); (void)IEC104_RemoteParameter_Process(rp.module);IEC104_RemoteParameter_Cancel(rp.module); CHECK(rp.closes==1);rp.send_fault=0;send_rp(preset1,16); CHECK(rp.handled==IEC104_REMOTE_PARAMETER_EVENT_HANDLED&&status().faulted_dropped==1); CHECK(status().pending_requests==0&&rp.calls[4]==0); push(stop_act,sizeof(stop_act));poll_rp();CHECK(status().faulted); close_rp(); } open_rp();send_rp(switch1,11);rp.check_fault=1;rp.close_fault=1; CHECK(execute()==IEC104_REMOTE_PARAMETER_EXECUTE_ERROR);rp.check_fault=0; CHECK(status().faulted&&rp.calls[1]==0&&rp.closes==1);close_rp(); open_rp();rp.lookup_mode=9;send_rp(read_all,8);rp.close_fault=1; CHECK(execute()==IEC104_REMOTE_PARAMETER_EXECUTE_OK);rp.check_fault=0; CHECK(status().faulted&&status().reads_aborted==1&&rp.lookups>0);close_rp(); } /** * 功能:验证以下场景与约束:确认超时且关链也失败时进入故障态,重复处理不得再次关链,并撤销活动计时器。 * 输入参数:无。 * 输出参数:无。 * 返回值:无。 * 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。 */ static void test_reply_timeout_close_once(void) { open_config(0,15000,60000,60000,10);rp.send_fault=1;rp.close_fault=1; send_rp(area1,9);CHECK(execute()==IEC104_REMOTE_PARAMETER_EXECUTE_OK);fake.now+=10; CHECK(!IEC104_RemoteParameter_Process(rp.module)); CHECK(status().faulted&&status().reply_timeouts==1&&status().close_errors==1&&rp.closes==1); (void)IEC104_RemoteParameter_Process(rp.module);CHECK(rp.closes==1&&!status().timer_active); close_rp(); } /** * 功能:验证以下场景与约束:发送恰遇未分派 STOP 时 ERROR 可延后而 FATAL 锁故障,两条路径最终均按一次 DISCARD 清理原预置。 * 输入参数:无。 * 输出参数:无。 * 返回值:无。 * 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。 */ static void test_stop_and_discard(void) { unsigned mode; for(mode=4;mode<=5;++mode) { open_rp();mirror(preset1,16,7);rp.send_fault=mode; send_rp(area1,9);CHECK(execute()==IEC104_REMOTE_PARAMETER_EXECUTE_OK); if(mode==4)CHECK(!status().faulted&&rp.closes==0); else CHECK(status().faulted&&rp.closes==1); events();CHECK(status().discard_pending);CHECK(execute()==IEC104_REMOTE_PARAMETER_EXECUTE_OK); CHECK(rp.calls[7]==1&&!rp.staged);close_rp(); } } /** * 功能:验证以下场景与约束:填满任务槽后验证多余请求丢弃,已接收请求逐一执行,响应保留 Slave、实例及连接代次身份。 * 输入参数:无。 * 输出参数:无。 * 返回值:无。 * 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。 */ static void test_slots_and_identity(void) { unsigned i; IEC104_SlaveEventIdentity_t identity; open_rp();rp.checked_fields=true; for(i=0;icount==1&&index==0&&ioa==0x8001); ++rp.lookups; switch(rp.lookup_mode) { case 0:result=IEC104_RemoteParameter_Add_Boolean(frame,ioa,true);break; case 1:result=IEC104_RemoteParameter_Add_Tiny(frame,ioa,-128);break; case 2:result=IEC104_RemoteParameter_Add_UTiny(frame,ioa,255);break; case 3:result=IEC104_RemoteParameter_Add_Short(frame,ioa,INT16_MIN);break; case 4:result=IEC104_RemoteParameter_Add_UShort(frame,ioa,UINT16_MAX);break; case 5:result=IEC104_RemoteParameter_Add_Int(frame,ioa,INT32_MIN);break; case 6:result=IEC104_RemoteParameter_Add_Uint(frame,ioa,UINT32_MAX);break; case 7:result=IEC104_RemoteParameter_Add_Long(frame,ioa,INT64_MIN);break; case 8:result=IEC104_RemoteParameter_Add_Ulong(frame,ioa,UINT64_MAX);break; case 9:result=IEC104_RemoteParameter_Add_Float(frame,ioa,-0.0f);break; case 10:result=IEC104_RemoteParameter_Add_Double(frame,ioa,1.0);break; case 11:result=IEC104_RemoteParameter_Add_Bytes(frame,ioa,bytes,3);break; case 12:result=IEC104_RemoteParameter_Add_String(frame,ioa,"DTU",3);break; case 13:result=IEC104_RemoteParameter_Add_Bytes(frame,ioa,NULL,0);break; case 14:result=IEC104_RemoteParameter_Add_String(frame,ioa,"A",1);break; case 15:memset(text,'X',sizeof(text));result=IEC104_RemoteParameter_Add_String(frame,ioa,text,63);break; case 16:memset(text,'X',sizeof(text));result=IEC104_RemoteParameter_Add_String(frame,ioa,text,64);break; case 17:result=IEC104_RemoteParameter_Add_String(frame,ioa,"",0);break; case 18:result=IEC104_RemoteParameter_Add_String(frame,ioa,"A\0B",3);break; case 19:result=IEC104_RemoteParameter_Add_String(frame,ioa,"\x80",1);break; case 20:result=IEC104_RemoteParameter_Add_Element(frame,0,4,bytes,3);break; case 21:result=IEC104_RemoteParameter_Add_Element(frame,0x1000000U,4,bytes,3);break; case 22:result=IEC104_RemoteParameter_Add_Element(frame,ioa,4,NULL,1);break; default:result=IEC104_RemoteParameter_Add_Element(frame,ioa,4,bytes,236);break; } if(rp.lookup_mode>=16)CHECK(result==IEC104_REMOTE_PARAMETER_ADD_ERROR); return result==IEC104_REMOTE_PARAMETER_ADD_OK?IEC104_REMOTE_PARAMETER_LOOKUP_ADDED:IEC104_REMOTE_PARAMETER_LOOKUP_ERROR; } /** * 功能:逐字节核对类型标记、长度和小端值编码,覆盖字符串终止符与长度边界,以及非法输入的否定确认。 * 输入参数:无。 * 输出参数:无。 * 返回值:无。 * 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。 */ static void test_typed_writers(void) { static const struct {uint8_t tag,length,value[8];} vectors[]={ {1,1,{1}},{43,1,{128}},{32,1,{255}},{33,2,{0,128}},{45,2,{255,255}}, {2,4,{0,0,0,128}},{35,4,{255,255,255,255}}, {36,8,{0,0,0,0,0,0,0,128}},{37,8,{255,255,255,255,255,255,255,255}}, {38,4,{0,0,0,128}},{39,8,{0,0,0,0,0,0,240,63}}, {4,3,{0,255,65}},{4,4,{68,84,85,0}},{4,0,{0}},{4,2,{65,0}} }; IEC104_RemoteParameterHandlers_t typed={action,typed_lookup}; unsigned mode; uint8_t expected[78]={202,1,7,17,1,0,1,0,0,1,128,0}; for(mode=0;mode<24;++mode){ open_rp();rp.lookup_mode=mode;send_rp(read1,11); CHECK(IEC104_RemoteParameter_Execute_Next(rp.module,&typed,&rp)==IEC104_REMOTE_PARAMETER_EXECUTE_OK); flush(); if(mode<15){expected[12]=vectors[mode].tag;expected[13]=vectors[mode].length; memcpy(expected+14,vectors[mode].value,vectors[mode].length);expect(0,expected,14U+vectors[mode].length); }else if(mode==15){expected[12]=4;expected[13]=64;memset(expected+14,'X',63);expected[77]=0;expect(0,expected,78); }else{uint8_t negative[11];memcpy(negative,read1,11);negative[2]=71;expect(0,negative,11);} close_rp(); } } /** * 功能:验证 TEST 读取保留测试位,并按请求顺序返回重复 IOA,不合并重复对象。 * 输入参数:无。 * 输出参数:无。 * 返回值:无。 * 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。 */ static void test_test_reads_and_duplicate_addresses(void) { const uint8_t duplicate[]={202,2,134,17,1,0,1,0,1,128,0,1,128,0}; const uint8_t expected[]={202,2,135,17,1,0,1,0,0,1,128,0,4,1,7,1,128,0,4,1,7}; open_rp();rp.width=1;exchange(duplicate,sizeof(duplicate),expected,sizeof(expected)); CHECK(rp.lookups==4&&status().read_frames==1);close_rp(); } /** * 功能:验证以下场景与约束:恢复门禁仅由同站、同 TEST 域取消解除。 * 输入参数:无。 * 输出参数:无。 * 返回值:无。 * 说明:成功取消的确认尚在等待时再次主动取消,不得重新建立门禁。 */ static void test_recovery_domains_and_rollback(void) { uint8_t bytes[16]; open_rp();mirror(preset1,16,7);IEC104_RemoteParameter_Cancel(rp.module); CHECK(execute()==IEC104_REMOTE_PARAMETER_EXECUTE_OK);CHECK(status().recovery_required); memcpy(bytes,cancel1,9);bytes[2]|=128;mirror(bytes,9,73);CHECK(status().recovery_required); memcpy(bytes,cancel1,9);bytes[4]=2;mirror(bytes,9,73);CHECK(status().recovery_required); memcpy(bytes,preset1,16);bytes[4]=2;mirror(bytes,16,71);CHECK(status().recovery_required); rp.send_fault=1;send_rp(cancel1,9);CHECK(execute()==IEC104_REMOTE_PARAMETER_EXECUTE_OK); CHECK(!status().recovery_required&&status().confirm_pending); IEC104_RemoteParameter_Cancel(rp.module);CHECK(!status().recovery_required&&!status().discard_pending); CHECK(rp.calls[7]==1&&rp.calls[6]==0);close_rp(); } /** * 功能:验证以下场景与约束:其他站点请求执行超时不得清理本域预置,原站仍可完成续帧并固化且不触发 DISCARD。 * 输入参数:无。 * 输出参数:无。 * 返回值:无。 * 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。 */ static void test_cross_station_expiry(void) { uint8_t bytes[16]; open_config(0,10,60000,60000,15000); memcpy(bytes,preset1,16);bytes[8]=129;mirror(bytes,16,7); bytes[4]=2;send_rp(bytes,16);fake.now+=10; CHECK(execute()==IEC104_REMOTE_PARAMETER_EXECUTE_OK);flush(); CHECK(status().timeouts==1&&status().preset_active&&!status().recovery_required&&rp.staged); bytes[4]=1;bytes[8]=128;mirror(bytes,16,7);mirror(solidify1,9,7); CHECK(rp.value==100&&rp.calls[7]==0);close_rp(); } /** * 功能:验证最大指定地址读取按帧容量分页,满长预置可容纳 48 个空值元素,多报一个对象则拒绝。 * 输入参数:无。 * 输出参数:无。 * 返回值:无。 * 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。 */ static void test_maximum_payloads(void) { uint8_t bytes[249]; const uint8_t *frames[128];size_t lengths[128];unsigned i; open_rp();rp.width=0;memcpy(bytes,read_all,8);bytes[1]=80; for(i=0;i<80;++i){bytes[8+3*i]=(uint8_t)(i+1);bytes[9+3*i]=128;bytes[10+3*i]=0;} send_rp(bytes,248);CHECK(execute()==IEC104_REMOTE_PARAMETER_EXECUTE_OK);flush(); CHECK(execute()==IEC104_REMOTE_PARAMETER_EXECUTE_OK);flush(); CHECK(collect(frames,lengths)==2&&lengths[0]==249&&lengths[1]==169); CHECK(frames[0][1]==48&&frames[0][8]==1&&frames[1][1]==32&&frames[1][8]==0); CHECK(rp.lookups==161&&status().reads_completed==1); clear_wire();memcpy(bytes,preset1,9);bytes[1]=48; for(i=0;i<48;++i){bytes[9+5*i]=(uint8_t)(i+1);bytes[10+5*i]=128;bytes[11+5*i]=0;bytes[12+5*i]=4;bytes[13+5*i]=0;} mirror(bytes,249,7);CHECK(rp.last.count==48);mirror(cancel1,9,9); bytes[1]=49;mirror(bytes,249,71);recover(); close_rp(); } /** * 功能:逐字节截断各请求,核对结构、IOA、站地址与原因的错误优先级,以及是否需要进入预置恢复。 * 输入参数:无。 * 输出参数:无。 * 返回值:无。 * 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。 */ static void test_truncated_boundaries(void) { size_t size; uint8_t bytes[16]; open_rp(); for(size=6;size<11;++size)mirror(switch1,size,71); for(size=6;size<9;++size)mirror(area1,size,71); for(size=6;size<11;++size)mirror(read1,size,71); for(size=6;size<16;++size){mirror(preset1,size,71);if(status().recovery_required)recover();} memcpy(bytes,switch1,11);bytes[6]=1;mirror(bytes,9,111); memcpy(bytes,preset1,16);bytes[9]=bytes[10]=bytes[11]=0;mirror(bytes,16,111);recover(); bytes[13]=4;mirror(bytes,16,71);recover(); /* Structure precedes IOA zero. */ memcpy(bytes,preset1,16);bytes[4]=99;mirror(bytes,16,110);CHECK(!status().recovery_required); memcpy(bytes,preset1,16);bytes[2]=10;mirror(bytes,16,109);CHECK(!status().recovery_required); close_rp(); } /** * 功能:验证以下场景与约束:模拟固化时资源预留失败与跨参数约束失败,验证两者均不更新正式值。 * 输入参数:无。 * 输出参数:无。 * 返回值:无。 * 说明:条件满足后才一次性应用暂存值。 */ static void test_constraint_group_reservation(void) { uint8_t bytes[16]; open_rp();rp.action_mode=5;rp.value=0;rp.current=100;rp.bad_index=1; memcpy(bytes,preset1,16);bytes[14]=150;mirror(bytes,16,7); mirror(solidify1,9,71);CHECK(rp.value==0&&rp.current==100&&!rp.staged);recover(); rp.bad_index=0;mirror(bytes,16,7);mirror(solidify1,9,71); CHECK(rp.value==0&&rp.current==100&&!rp.staged);recover(); rp.current=200;mirror(bytes,16,7);mirror(solidify1,9,7); CHECK(rp.value==150&&rp.current==200&&!rp.staged);close_rp(); } /** * 功能:验证以下场景与约束:未初始化传输层的空闲实例应可处理、空执行和销毁。 * 输入参数:无。 * 输出参数:无。 * 返回值:无。 * 说明:状态查询失败必须保持调用方输出逐字节不变。 */ static void test_initial_idle_and_readonly_failure(void) { IEC104_RemoteParameterStatus_t before,after; memset(&rp,0,sizeof(rp));memset(&fake,0,sizeof(fake));fake.now=1000; rp.slave=IEC104_Slave_Create();CHECK(rp.slave!=NULL); IEC104_RemoteParameter_Config_Default(&rp.config); rp.module=IEC104_RemoteParameter_Create(rp.slave,&rp.config);CHECK(rp.module!=NULL); CHECK(IEC104_RemoteParameter_Process(rp.module)); CHECK(execute()==IEC104_REMOTE_PARAMETER_EXECUTE_EMPTY); CHECK(!status().faulted&&!status().active); CHECK(IEC104_RemoteParameter_Destroy(rp.module)); CHECK(IEC104_Slave_Destroy(rp.slave,NULL)==IEC104_TCP_OK); open_rp();memset(&before,0xA5,sizeof(before));after=before;rp.query_fault=1; CHECK(!IEC104_RemoteParameter_Get_Status(rp.module,&after));CHECK(memcmp(&before,&after,sizeof(before))==0); rp.query_fault=0;close_rp(); } /** * 功能:验证以下场景与约束:主动取消尚未处理的错误预置仍保留恢复门禁。 * 输入参数:无。 * 输出参数:无。 * 返回值:无。 * 说明:已超时的协议取消仅返回否定确认,不调用业务取消或丢弃暂存。 */ static void test_cancel_unprocessed_error_and_expired_cancel(void) { uint8_t bytes[16],expected[9]; open_rp();memcpy(bytes,preset1,16);bytes[13]=4; if(IEC104_REMOTE_PARAMETER_TASK_CAPACITY>=2U){queue(switch1,11);queue(bytes,16);poll_rp();} else {rp.send_fault=1;send_rp(bytes,16);} IEC104_RemoteParameter_Cancel(rp.module); CHECK(status().recovery_required&&!status().discard_pending&&rp.calls[1]==0&&rp.calls[4]==0); rp.send_fault=0;recover();close_rp(); open_config(0,10,60000,60000,15000);mirror(preset1,16,7);clear_wire(); send_rp(cancel1,9);fake.now+=10;CHECK(execute()==IEC104_REMOTE_PARAMETER_EXECUTE_OK);flush(); memcpy(expected,cancel1,9);expected[2]=73;expected[8]=64;expect(0,expected,9); CHECK(status().preset_active&&rp.staged&&rp.calls[6]==0);close_rp(); } /** * 功能:验证以下场景与约束:动作已应用后身份检查失败,应保留业务结果并进入故障态、尝试关链,不能将其当作未执行请求撤销。 * 输入参数:无。 * 输出参数:无。 * 返回值:无。 * 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。 */ static void test_post_action_failure(void) { open_rp();rp.action_mode=3;rp.close_fault=1;send_rp(switch1,11); CHECK(execute()==IEC104_REMOTE_PARAMETER_EXECUTE_OK);rp.check_fault=0; CHECK(rp.current==1&&rp.calls[1]==1&&status().faulted&&rp.closes==1); CHECK(!IEC104_RemoteParameter_Destroy(rp.module));close_rp(); } /** * 功能:验证以下场景与约束:无需业务回调的拒绝或恢复确认发送失败时直接锁故障。 * 输入参数:无。 * 输出参数:无。 * 返回值:无。 * 说明:队列中错误响应成为待确认项后即启动回复期限,不能被前一请求执行时间掩盖。 */ static void test_pre_callback_send_failure_and_reply_start(void) { unsigned mode; for(mode=2;mode<=3;++mode){ open_rp();rp.send_fault=mode;rp.close_fault=1;send_rp(solidify1,9); CHECK(execute()==IEC104_REMOTE_PARAMETER_EXECUTE_ERROR); CHECK(status().faulted&&rp.calls[5]==0&&rp.closes==1);close_rp(); open_rp();send_rp(preset1,16);IEC104_RemoteParameter_Cancel(rp.module); CHECK(status().recovery_required);rp.send_fault=mode;rp.close_fault=1;send_rp(cancel1,9); CHECK(execute()==IEC104_REMOTE_PARAMETER_EXECUTE_ERROR); CHECK(status().faulted&&rp.calls[6]==0&&rp.closes==1);close_rp(); } if(IEC104_REMOTE_PARAMETER_TASK_CAPACITY>=2U){ open_config(0,15000,60000,60000,10);rp.checked_fields=true; queue(switch1,11);queue(area1,8);poll_rp(); CHECK(execute()==IEC104_REMOTE_PARAMETER_EXECUTE_OK); CHECK(status().pending_requests==1&&status().confirm_pending); fake.now+=10;CHECK(IEC104_RemoteParameter_Process(rp.module)); CHECK(status().reply_timeouts==1&&rp.closes==1);events();close_rp(); } } #define RUN(fn) do { ++groups; printf("RUN %u %s\n",groups,#fn); fn(); } while(0) /** * 功能:运行遥调协议、事务隔离、读取分页及故障边界各组测试,输出通过组数与实例容量配置。 * 输入参数:无。 * 输出参数:无。 * 返回值:正常完成返回 0;参数、运行或断言失败以非零状态结束进程。 * 说明:本辅助入口用于构造或核对上述测试场景,相关状态保存在当前测试夹具中。 */ int main(void) { RUN(test_configuration); RUN(test_wire_validation); RUN(test_tags); RUN(test_actions_and_fields); RUN(test_confirm_modes); RUN(test_preset_failures); RUN(test_cross_station_and_test); RUN(test_error_batch_fifo); RUN(test_cancel_recovery); RUN(test_late_preset_deadline); RUN(test_execution_deadline); RUN(test_read_stream); RUN(test_read_wait_and_abort); RUN(test_lookup_contract); RUN(test_read_deadlines); RUN(test_faults); RUN(test_reply_timeout_close_once); RUN(test_stop_and_discard); RUN(test_slots_and_identity); RUN(test_station_replacement); RUN(test_typed_writers); RUN(test_test_reads_and_duplicate_addresses); RUN(test_recovery_domains_and_rollback); RUN(test_cross_station_expiry); RUN(test_maximum_payloads); RUN(test_truncated_boundaries); RUN(test_constraint_group_reservation); RUN(test_initial_idle_and_readonly_failure); RUN(test_cancel_unprocessed_error_and_expired_cancel); RUN(test_post_action_failure); RUN(test_pre_callback_send_failure_and_reply_start); printf("RemoteParameter: %u groups PASS (TCP=%u TASK=%u)\n",groups, (unsigned)IEC104_TCP_SERVER_CAPACITY,(unsigned)IEC104_REMOTE_PARAMETER_TASK_CAPACITY); return 0; }