1351 lines
65 KiB
C
1351 lines
65 KiB
C
/* 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<sizeof(tags);++i) {
|
|
memcpy(bytes,preset1,14); bytes[12]=tags[i]; bytes[13]=sizes[i]; memset(bytes+14,0,235);
|
|
mirror(bytes,14U+sizes[i],7);
|
|
CHECK(status().preset_active); mirror(cancel1,sizeof(cancel1),9);
|
|
if (tags[i] != 4) {
|
|
bytes[13]=(uint8_t)(sizes[i]+1U); mirror(bytes,14U+bytes[13],71); recover();
|
|
}
|
|
}
|
|
memcpy(bytes,preset1,16); bytes[12]=1; bytes[13]=1; bytes[14]=2; mirror(bytes,15,71); recover();
|
|
bytes[12]=38; bytes[13]=4; bytes[14]=0; bytes[15]=0; bytes[16]=128; bytes[17]=127;
|
|
mirror(bytes,18,71); recover(); bytes[17]=255; mirror(bytes,18,71); recover();
|
|
bytes[16]=192; mirror(bytes,18,71); recover();
|
|
bytes[14]=0;bytes[15]=0;bytes[16]=0;bytes[17]=128; mirror(bytes,18,7); mirror(cancel1,9,9);
|
|
bytes[14]=1;bytes[17]=0; mirror(bytes,18,7); mirror(cancel1,9,9);
|
|
bytes[12]=39;bytes[13]=8;memset(bytes+14,0,8);bytes[20]=240;bytes[21]=127;
|
|
mirror(bytes,22,71);recover();bytes[21]=255;mirror(bytes,22,71);recover();
|
|
bytes[20]=248;mirror(bytes,22,71);recover();
|
|
bytes[12]=4;bytes[13]=235;memset(bytes+14,42,235);mirror(bytes,249,7);mirror(cancel1,9,9);
|
|
bytes[13]=236;mirror(bytes,249,71);recover();
|
|
close_rp();
|
|
}
|
|
|
|
/**
|
|
* 功能:核对区切换、读区、预置与取消的回调字段和结果映射,并验证 TEST 副作用隔离及回调重入保护。
|
|
* 输入参数:无。
|
|
* 输出参数:无。
|
|
* 返回值:无。
|
|
* 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。
|
|
*/
|
|
static void test_actions_and_fields(void)
|
|
{
|
|
uint8_t test[16], reply[] = {201,1,7,17,1,0,0,0,0,1,0,0,0,4,0};
|
|
IEC104_RemoteParameterElement_t unused;
|
|
open_rp(); mirror(switch1,11,7); CHECK(rp.current==1);
|
|
exchange(area1,9,reply,sizeof(reply)); CHECK(rp.last.sn==0);
|
|
rp.action_mode=1; mirror(area1,9,71); CHECK(status().invalid_callbacks==1);
|
|
rp.action_mode=0; rp.result=IEC104_REMOTE_PARAMETER_ACTION_UNKNOWN_IOA; mirror(switch1,11,71);
|
|
rp.result=(IEC104_RemoteParameterActionResult_t)99;mirror(switch1,11,71);
|
|
rp.result=IEC104_REMOTE_PARAMETER_ACTION_APPLIED;
|
|
memcpy(test,switch1,11);test[2]|=128;test[9]=99;mirror(test,11,7);CHECK(rp.current==1);
|
|
CHECK(rp.calls[1]==3);
|
|
{ unsigned long executed=status().executed,applied=status().applied;
|
|
memcpy(test,area1,9);test[2]|=128;reply[2]|=128;exchange(test,9,reply,15);
|
|
CHECK(status().executed==executed&&status().applied==applied); }
|
|
CHECK(rp.last.test&&rp.calls[2]==3);
|
|
rp.action_mode=2;mirror(switch1,11,7);rp.action_mode=0;
|
|
mirror(preset1,16,7);CHECK(rp.first.first_frame&&!rp.first.more_follows);
|
|
CHECK(!IEC104_RemoteParameter_Get_Element(&rp.last,0,&unused));
|
|
memcpy(test,cancel1,9);test[6]=2;mirror(test,9,9);
|
|
CHECK(rp.last.sn==2 && rp.staged_sn==1 && !rp.staged);
|
|
CHECK(!status().preset_active&&!status().recovery_required);
|
|
close_rp();
|
|
}
|
|
|
|
/**
|
|
* 功能:验证以下场景与约束:对比镜像与紧凑预置确认,核对多帧首尾标志、未收齐时禁止固化、末帧重复拒绝及唯一固化。
|
|
* 输入参数:无。
|
|
* 输出参数:无。
|
|
* 返回值:无。
|
|
* 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。
|
|
*/
|
|
static void test_confirm_modes(void)
|
|
{
|
|
unsigned mode;
|
|
uint8_t bytes[16], compact[] = {203,0,7,17,1,0,1,0,129};
|
|
for(mode=0;mode<2;++mode) {
|
|
open_config(mode,15000,60000,60000,15000);
|
|
memcpy(bytes,preset1,16);bytes[8]=129;
|
|
if(mode==0)mirror(bytes,16,7);else exchange(bytes,16,compact,9);
|
|
CHECK(rp.first.first_frame&&rp.first.more_follows);
|
|
mirror(solidify1,9,71);CHECK(status().preset_active);
|
|
bytes[14]=101;
|
|
if(mode==0)mirror(bytes,16,7);else exchange(bytes,16,compact,9);
|
|
CHECK(!rp.last.first_frame&&rp.last.more_follows);
|
|
bytes[8]=128;compact[8]=128;
|
|
if(mode==0)mirror(bytes,16,7);else exchange(bytes,16,compact,9);
|
|
mirror(bytes,16,71);CHECK(status().preset_active);
|
|
mirror(solidify1,9,7);CHECK(rp.value==101&&!status().preset_active);
|
|
CHECK(status().presets_opened==1&&status().solidified==1);
|
|
mirror(cancel1,9,73);close_rp();compact[8]=129;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 功能:覆盖未知 IOA、固化拒绝及续帧定值区变化后的恢复门禁和 DISCARD,同时验证取消拒绝仍结束本地预置。
|
|
* 输入参数:无。
|
|
* 输出参数:无。
|
|
* 返回值:无。
|
|
* 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。
|
|
*/
|
|
static void test_preset_failures(void)
|
|
{
|
|
uint8_t bytes[16];
|
|
open_rp();
|
|
rp.result=IEC104_REMOTE_PARAMETER_ACTION_UNKNOWN_IOA;mirror(preset1,16,111);
|
|
CHECK(status().recovery_required&&!rp.staged&&status().unknown_ioa==1);recover();
|
|
rp.result=IEC104_REMOTE_PARAMETER_ACTION_APPLIED;mirror(preset1,16,7);
|
|
rp.result=IEC104_REMOTE_PARAMETER_ACTION_REJECTED;mirror(solidify1,9,71);
|
|
CHECK(rp.value==7&&!rp.staged&&status().recovery_required);recover();
|
|
rp.result=IEC104_REMOTE_PARAMETER_ACTION_APPLIED;memcpy(bytes,preset1,16);bytes[8]=129;mirror(bytes,16,7);
|
|
bytes[6]=2;clear_wire();send_rp(bytes,16);CHECK(execute()==IEC104_REMOTE_PARAMETER_EXECUTE_OK);
|
|
if(status().discard_pending)CHECK(execute()==IEC104_REMOTE_PARAMETER_EXECUTE_OK);
|
|
flush();CHECK(status().recovery_required&&!rp.staged&&rp.calls[7]==1);recover();
|
|
mirror(preset1,16,7);rp.result=IEC104_REMOTE_PARAMETER_ACTION_REJECTED;mirror(cancel1,9,73);
|
|
CHECK(!status().recovery_required&&!status().preset_active&&!rp.staged);
|
|
close_rp();
|
|
}
|
|
|
|
/**
|
|
* 功能:验证跨站及普通/TEST 请求不能接续或取消另一域的预置,纯 TEST 事务不修改业务暂存值。
|
|
* 输入参数:无。
|
|
* 输出参数:无。
|
|
* 返回值:无。
|
|
* 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。
|
|
*/
|
|
static void test_cross_station_and_test(void)
|
|
{
|
|
uint8_t bytes[16], cancel[9];
|
|
open_rp();memcpy(bytes,preset1,16);bytes[8]=129;mirror(bytes,16,7);
|
|
bytes[4]=2;mirror(bytes,16,71);CHECK(status().preset_active&&rp.staged);
|
|
bytes[13]=3;mirror(bytes,16,71);CHECK(status().preset_active&&rp.staged);
|
|
memcpy(bytes,preset1,16);bytes[2]|=128;mirror(bytes,16,71);CHECK(rp.calls[4]==1);
|
|
memcpy(cancel,cancel1,9);cancel[2]|=128;mirror(cancel,9,73);CHECK(rp.staged);
|
|
mirror(cancel1,9,9);
|
|
memcpy(bytes,preset1,16);bytes[2]|=128;mirror(bytes,16,7);CHECK(!rp.staged&&status().preset_active);
|
|
mirror(solidify1,9,71);mirror(cancel1,9,73);CHECK(status().preset_active);
|
|
mirror(cancel,9,9);CHECK(!status().preset_active&&rp.calls[6]==1);
|
|
close_rp();
|
|
}
|
|
|
|
/**
|
|
* 功能:验证以下场景与约束:批量首帧与错误续帧按接收顺序处理,已打开预置须 DISCARD。
|
|
* 输入参数:无。
|
|
* 输出参数:无。
|
|
* 返回值:无。
|
|
* 说明:无关原因及末帧后的错误不破坏现有预置。
|
|
*/
|
|
static void test_error_batch_fifo(void)
|
|
{
|
|
uint8_t bytes[16];
|
|
open_rp();memcpy(bytes,preset1,16);bytes[8]=129;
|
|
if(IEC104_REMOTE_PARAMETER_TASK_CAPACITY>=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;i<IEC104_REMOTE_PARAMETER_TASK_CAPACITY+1U;++i)queue(switch1,11);
|
|
poll_rp();CHECK(status().pending_requests==IEC104_REMOTE_PARAMETER_TASK_CAPACITY);
|
|
CHECK(status().dropped_requests==1);
|
|
CHECK(IEC104_Slave_Get_Event_Identity(rp.slave,&rp.input,&identity));
|
|
for(i=0;i<IEC104_REMOTE_PARAMETER_TASK_CAPACITY;++i){CHECK(execute()==IEC104_REMOTE_PARAMETER_EXECUTE_OK);flush();}
|
|
CHECK(rp.calls[1]==IEC104_REMOTE_PARAMETER_TASK_CAPACITY);
|
|
CHECK(rp.sent_identity.slave==identity.slave&&rp.sent_identity.instance_id==identity.instance_id&&rp.sent_identity.generation==identity.generation);
|
|
close_rp();
|
|
}
|
|
|
|
/**
|
|
* 功能:验证以下场景与约束:同地址站点替换不能继承旧预置。
|
|
* 输入参数:无。
|
|
* 输出参数:无。
|
|
* 返回值:无。
|
|
* 说明:旧站引用保持到 DISCARD 完成,清理仍使用原站身份。
|
|
*/
|
|
static void test_station_replacement(void)
|
|
{
|
|
uint8_t bytes[16];
|
|
open_rp();memcpy(bytes,preset1,16);bytes[8]=129;mirror(bytes,16,7);
|
|
CHECK(IEC104_Slave_Remove_Station(rp.slave,&rp.stations[0])==IEC104_STATION_OK);
|
|
CHECK(!IEC104_Station_Is_Reusable(&rp.stations[0]));
|
|
CHECK(IEC104_Slave_Add_Station(rp.slave,&rp.stations[2],1,&rp)==IEC104_STATION_OK);
|
|
bytes[8]=128;mirror(bytes,16,71);mirror(solidify1,9,71);mirror(cancel1,9,73);
|
|
CHECK(status().preset_active&&rp.calls[4]==1);
|
|
IEC104_RemoteParameter_Cancel(rp.module);CHECK(execute()==IEC104_REMOTE_PARAMETER_EXECUTE_OK);
|
|
CHECK(rp.last.station_id==rp.first.station_id&&rp.calls[7]==1);
|
|
close_rp();
|
|
}
|
|
|
|
/**
|
|
* 功能:按模式调用各类型定值写入器,生成数值边界和字符串样本,并断言非法地址、指针及长度立即被拒绝。
|
|
* 输入参数:context——业务回调的测试上下文;request——当前业务请求(只读);index——待访问或核对的条目下标;ioa——信息对象地址;frame——读取结果帧或报文缓冲区。
|
|
* 输出参数:frame——追加定值元素后的读取帧。
|
|
* 返回值:查值结果,区分追加成功、结束/跳过、容量不足及失败。
|
|
* 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。
|
|
*/
|
|
static IEC104_RemoteParameterLookupResult_t typed_lookup(void *context,
|
|
const IEC104_RemoteParameterRequest_t *request, size_t index, uint32_t ioa,
|
|
IEC104_RemoteParameterFrame_t *frame)
|
|
{
|
|
IEC104_RemoteParameterAddResult_t result;
|
|
const uint8_t bytes[] = {0,255,65};
|
|
char text[64];
|
|
CHECK(context==&rp&&request->count==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;
|
|
}
|