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