1009 lines
50 KiB
C
1009 lines
50 KiB
C
/* Type211公开契约测试:独立报文字节向量、可控Net、真实Slave和ACK发送链。
|
||
* 分区:故障注入与动作记录 -> 成帧/收尾夹具 -> 校验/会话/ACK/期限/引用/故障用例。
|
||
* UPGRADE_TEST_POLICY与TCP/任务槽容量由构建矩阵指定;同一用例验证两种ACK策略。
|
||
* 本程序不写升级文件、不重启设备、不修改宿主时钟;包与激活行为由Example专项覆盖。 */
|
||
#include "iec104_test_config.h"
|
||
#include "iec104_tcp_fixture.h"
|
||
#include "IEC104_SoftwareUpgrade.h"
|
||
|
||
#ifndef IEC104_SOFTWARE_UPGRADE_TASK_CAPACITY
|
||
#define IEC104_SOFTWARE_UPGRADE_TASK_CAPACITY 2U
|
||
#endif
|
||
#ifndef UPGRADE_TEST_POLICY
|
||
#define UPGRADE_TEST_POLICY 0
|
||
#endif
|
||
|
||
/* 每个open_case重置所有替身;override=-9表示走真实接口,避免注入泄漏到下一组。
|
||
* business_now可只回拨业务时钟,不同时破坏传输层的单调时间前提。 */
|
||
static IEC104_Slave_t *slave;
|
||
static IEC104_SoftwareUpgrade_t *upgrade;
|
||
static IEC104_Station_t stations[3];
|
||
static IEC104_SoftwareUpgradeStatus_t status;
|
||
static IEC104_SlaveEvent_t input_event;
|
||
static IEC104_SoftwareUpgradeRequest_t calls[32];
|
||
static IEC104_SlaveAckReceipt_t last_receipt;
|
||
static unsigned call_count, groups, next_ns, executed, close_calls, send_calls;
|
||
static int decision, send_override, ack_send_override, ack_override, check_override;
|
||
static int status_error, status_mutation, close_error, reenter, stop_on_send, fatal_on_stop;
|
||
static uint64_t ack_time, action_duration, business_now = UINT64_MAX;
|
||
/* 三种请求特意使用不同OA、IOA和CTYPE低位,暴露镜像或ABANDON误用后续请求的问题。 */
|
||
static const uint8_t start_request[] = {211U,0U,6U,0x37U,1U,0U,0x56U,0x34U,0x12U,0x95U};
|
||
static const uint8_t end_request[] = {211U,0U,6U,0x38U,1U,0U,3U,2U,1U,0x15U};
|
||
static const uint8_t cancel_request[] = {211U,0U,8U,0x39U,1U,0U,9U,8U,7U,0x16U};
|
||
|
||
/**
|
||
* 功能:默认沿用网络夹具时钟。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:本次采样的时钟毫秒值。
|
||
* 说明:指定business_now时仅覆盖升级业务时间以独立构造回拨。
|
||
*/
|
||
uint64_t IEC104_SoftwareUpgrade_Test_Now_Ms(void) { return business_now == UINT64_MAX ? fake.now : business_now; }
|
||
|
||
/**
|
||
* 功能:在发送调用内部推进STOP,但不消费通知,构造“传输已停、模块尚未知晓”的窄窗口。
|
||
* 输入参数:s——被测 Slave 实例;id——请求所属的 Slave、实例及连接代次身份(只读);asdu——ASDU 容器(只读)。
|
||
* 输出参数:无。
|
||
* 返回值:发送提交结果,区分接收成功、WAIT、ERROR 与 FATAL。
|
||
* 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。
|
||
*/
|
||
IEC104_TcpSubmitResult_t IEC104_SoftwareUpgrade_Test_Send_Response(IEC104_Slave_t *s,
|
||
const IEC104_SlaveEventIdentity_t *id, const IEC60870_Asdu_t *asdu)
|
||
{
|
||
++send_calls;
|
||
if (stop_on_send) {
|
||
stop_on_send = 0; push(stop_act, sizeof(stop_act));
|
||
CHECK(IEC104_Slave_Poll(s, 0U, NULL) == IEC104_TCP_OK);
|
||
return fatal_on_stop ? IEC104_TCP_SUBMIT_FATAL : IEC104_TCP_SUBMIT_ERROR;
|
||
}
|
||
if (send_override != -9) { return (IEC104_TcpSubmitResult_t)send_override; }
|
||
return IEC104_Slave_Send_Response(s, id, asdu);
|
||
}
|
||
|
||
/**
|
||
* 功能:统计带ACK确认的提交次数,支持强制返回值。
|
||
* 输入参数:s——被测 Slave 实例;id——请求所属的 Slave、实例及连接代次身份(只读);asdu——ASDU 容器(只读);receipt——带连接身份的 ACK 回执。
|
||
* 输出参数:receipt——提交成功时返回的 ACK 回执。
|
||
* 返回值:发送提交结果,区分接收成功、WAIT、ERROR 与 FATAL。
|
||
* 说明:真实提交成功后保存回执供后续断言。
|
||
*/
|
||
IEC104_TcpSubmitResult_t IEC104_SoftwareUpgrade_Test_Send_Response_Acked(IEC104_Slave_t *s,
|
||
const IEC104_SlaveEventIdentity_t *id, const IEC60870_Asdu_t *asdu, IEC104_SlaveAckReceipt_t *receipt)
|
||
{
|
||
IEC104_TcpSubmitResult_t result;
|
||
++send_calls;
|
||
if (ack_send_override != -9) { return (IEC104_TcpSubmitResult_t)ack_send_override; }
|
||
result = IEC104_Slave_Send_Response_Acked(s, id, asdu, receipt);
|
||
if (result == IEC104_TCP_SUBMIT_OK) { last_receipt = *receipt; }
|
||
return result;
|
||
}
|
||
|
||
/**
|
||
* 功能:返回配置的ACK状态,仅在已确认且输出指针有效时写入注入的确认时刻。
|
||
* 输入参数:at——ACK 确认时刻的存储(毫秒)。
|
||
* 输出参数:at——已 ACK 时写入的确认时刻(毫秒)。
|
||
* 返回值:ACK 生命周期状态,区分排队、已发送、已确认及无效回执。
|
||
* 说明:本辅助入口用于构造或核对上述测试场景,相关状态保存在当前测试夹具中。
|
||
*/
|
||
static IEC104_SlaveAckState_t override_ack(uint64_t *at)
|
||
{
|
||
if (ack_override == IEC104_SLAVE_ACK_ACKED && at != NULL) { *at = ack_time; }
|
||
return (IEC104_SlaveAckState_t)ack_override;
|
||
}
|
||
/**
|
||
* 功能:为允许历史连接的ACK查询提供替身。
|
||
* 输入参数:s——被测 Slave 实例(只读);receipt——带连接身份的 ACK 回执(只读);at——ACK 确认时刻的存储(毫秒)。
|
||
* 输出参数:at——已 ACK 时写入的确认时刻(毫秒)。
|
||
* 返回值:ACK 生命周期状态,区分排队、已发送、已确认及无效回执。
|
||
* 说明:未配置注入时转调真实回执接口。
|
||
*/
|
||
IEC104_SlaveAckState_t IEC104_SoftwareUpgrade_Test_Get_Ack_State(const IEC104_Slave_t *s,
|
||
const IEC104_SlaveAckReceipt_t *receipt, uint64_t *at)
|
||
{
|
||
return ack_override == -9 ? IEC104_Slave_Get_Ack_State(s, receipt, at) : override_ack(at);
|
||
}
|
||
/**
|
||
* 功能:为要求活动连接的ACK查询提供同一注入,正常路径保留真实活动身份校验。
|
||
* 输入参数:s——被测 Slave 实例(只读);receipt——带连接身份的 ACK 回执(只读);at——ACK 确认时刻的存储(毫秒)。
|
||
* 输出参数:at——已 ACK 时写入的确认时刻(毫秒)。
|
||
* 返回值:ACK 生命周期状态,区分排队、已发送、已确认及无效回执。
|
||
* 说明:本辅助入口用于构造或核对上述测试场景,相关状态保存在当前测试夹具中。
|
||
*/
|
||
IEC104_SlaveAckState_t IEC104_SoftwareUpgrade_Test_Get_Active_Ack_State(const IEC104_Slave_t *s,
|
||
const IEC104_SlaveAckReceipt_t *receipt, uint64_t *at)
|
||
{
|
||
return ack_override == -9 ? IEC104_Slave_Get_Active_Ack_State(s, receipt, at) : override_ack(at);
|
||
}
|
||
/**
|
||
* 功能:覆盖请求身份的就绪查询,或在未注入时使用真实Slave通知与代次状态。
|
||
* 输入参数:s——被测 Slave 实例(只读);id——请求所属的 Slave、实例及连接代次身份(只读)。
|
||
* 输出参数:无。
|
||
* 返回值:请求身份的可执行、待事件、过期或错误状态。
|
||
* 说明:本辅助入口用于构造或核对上述测试场景,相关状态保存在当前测试夹具中。
|
||
*/
|
||
IEC104_SlaveRequestState_t IEC104_SoftwareUpgrade_Test_Check_Request(const IEC104_Slave_t *s,
|
||
const IEC104_SlaveEventIdentity_t *id)
|
||
{
|
||
return check_override == -9 ? IEC104_Slave_Check_Request(s, id) : (IEC104_SlaveRequestState_t)check_override;
|
||
}
|
||
/**
|
||
* 功能:每次只破坏一个STOP让出条件,验证真实发送故障不能仅凭有未读通知而被吞掉。
|
||
* 输入参数:s——被测 Slave 实例(只读);out——TCP 状态快照输出存储;error——底层错误码存储。
|
||
* 输出参数:out——查询或构造结果;error——底层错误码存储。
|
||
* 返回值:真实传输接口或故障注入产生的 TCP 操作结果。
|
||
* 说明:本辅助入口用于构造或核对上述测试场景,相关状态保存在当前测试夹具中。
|
||
*/
|
||
IEC104_TcpResult_t IEC104_SoftwareUpgrade_Test_Get_Status(const IEC104_Slave_t *s,
|
||
IEC104_TcpServerStatus_t *out, IEC104_TcpError_t *error)
|
||
{
|
||
IEC104_TcpResult_t result;
|
||
if (status_error) { return IEC104_TCP_INTERNAL_ERROR; }
|
||
result = IEC104_Slave_Get_Status(s, out, error);
|
||
if (result != IEC104_TCP_OK) { return result; }
|
||
switch (status_mutation) {
|
||
case 1: ++out->generation; break;
|
||
case 2: out->connected = false; break;
|
||
case 3: out->connection_status_valid = false; break;
|
||
case 4: out->asdu_queue_status_valid = false; break;
|
||
case 5: out->connection.phase = (IEC104_TcpSessionPhase_t)99; break;
|
||
case 6: out->connection.fault = (IEC104_TcpFault_t)99; break;
|
||
case 7: out->connection.data_transfer_started = true; break;
|
||
case 8: out->pending_event_count = 0U; break;
|
||
default: break;
|
||
}
|
||
return result;
|
||
}
|
||
/**
|
||
* 功能:记录故障关链尝试。
|
||
* 输入参数:s——被测 Slave 实例;id——请求所属的 Slave、实例及连接代次身份(只读);error——底层错误码存储。
|
||
* 输出参数:error——底层错误码存储。
|
||
* 返回值:真实传输接口或故障注入产生的 TCP 操作结果。
|
||
* 说明:可强制关链失败以验证重试,否则按真实身份关闭连接。
|
||
*/
|
||
IEC104_TcpResult_t IEC104_SoftwareUpgrade_Test_Close_Connection_By_Identity(IEC104_Slave_t *s,
|
||
const IEC104_SlaveEventIdentity_t *id, IEC104_TcpError_t *error)
|
||
{
|
||
++close_calls;
|
||
return close_error ? IEC104_TCP_INTERNAL_ERROR : IEC104_Slave_Close_Connection_By_Identity(s, id, error);
|
||
}
|
||
|
||
/**
|
||
* 功能:刷新升级状态快照,查询失败立即作为测试失败。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。
|
||
*/
|
||
static void refresh(void) { CHECK(IEC104_SoftwareUpgrade_Get_Status(upgrade, &status)); }
|
||
/**
|
||
* 功能:保存请求的值副本,不保留回调指针。
|
||
* 输入参数:context——业务回调的测试上下文;request——当前业务请求(只读)。
|
||
* 输出参数:无。
|
||
* 返回值:动作回调的接受或拒绝决定。
|
||
* 说明:同时检查站点引用在动作/ABANDON交付期间仍有效。
|
||
* action_duration用于证明END回调耗时也计入ACK期限,reenter检查只读与修改入口的区别。
|
||
*/
|
||
static IEC104_SoftwareUpgradeDecision_t action(void *context, const IEC104_SoftwareUpgradeRequest_t *request)
|
||
{
|
||
CHECK(context == &call_count && request != NULL && call_count < 32U);
|
||
CHECK(request->station_id != 0U && request->session_serial != 0U);
|
||
CHECK(IEC104_Slave_Get_Station_By_Id(slave, request->station_id) != NULL);
|
||
calls[call_count++] = *request;
|
||
if (reenter) {
|
||
IEC104_SoftwareUpgradeRequest_t output;
|
||
refresh();
|
||
CHECK(!IEC104_SoftwareUpgrade_Destroy(upgrade));
|
||
CHECK(!IEC104_SoftwareUpgrade_Process(upgrade));
|
||
CHECK(IEC104_SoftwareUpgrade_Execute_Next(upgrade, action, context) == IEC104_SOFTWARE_UPGRADE_EXECUTE_ERROR);
|
||
CHECK(IEC104_SoftwareUpgrade_Handle_Event(upgrade, &input_event) == IEC104_SOFTWARE_UPGRADE_EVENT_ERROR);
|
||
CHECK(!IEC104_SoftwareUpgrade_Take_Restart(upgrade, &output));
|
||
IEC104_SoftwareUpgrade_Cancel(upgrade);
|
||
}
|
||
fake.now += action_duration;
|
||
return (IEC104_SoftwareUpgradeDecision_t)decision;
|
||
}
|
||
/**
|
||
* 功能:统计Execute_Next调用次数并绑定记录动作的上下文,原样返回本次执行结果。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:单步执行结果,区分已执行、无任务、等待及错误。
|
||
* 说明:本辅助入口用于构造或核对上述测试场景,相关状态保存在当前测试夹具中。
|
||
*/
|
||
static IEC104_SoftwareUpgradeExecuteResult_t execute(void)
|
||
{
|
||
++executed;
|
||
return IEC104_SoftwareUpgrade_Execute_Next(upgrade, action, &call_count);
|
||
}
|
||
/**
|
||
* 功能:按FIFO分派全部Slave通知,并保存最近I帧的值副本供身份和重入用例使用。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。
|
||
*/
|
||
static void dispatch(void)
|
||
{
|
||
IEC104_SlaveEvent_t event;
|
||
IEC104_TcpEventResult_t result;
|
||
while ((result = IEC104_Slave_NextEvent(slave, &event)) == IEC104_TCP_EVENT_READY) {
|
||
IEC104_SoftwareUpgradeEventResult_t handled = IEC104_SoftwareUpgrade_Handle_Event(upgrade, &event);
|
||
CHECK(handled != IEC104_SOFTWARE_UPGRADE_EVENT_ERROR);
|
||
if (event.transport.type == IEC104_TCP_EVENT_I_FRAME) { CHECK(IEC104_Slave_Copy_Event(&input_event, &event)); }
|
||
}
|
||
CHECK(result == IEC104_TCP_EVENT_EMPTY);
|
||
}
|
||
/**
|
||
* 功能:非阻塞推进一次传输并排空升级通知,失败时报告用例编号、时间和动作次数。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。
|
||
*/
|
||
static void poll(void)
|
||
{
|
||
IEC104_TcpResult_t result = IEC104_Slave_Poll(slave, 0U, NULL);
|
||
if (result != IEC104_TCP_OK) { fprintf(stderr, "poll group=%u now=%llu calls=%u result=%d\n",
|
||
groups, (unsigned long long)fake.now, call_count, (int)result); }
|
||
CHECK(result == IEC104_TCP_OK); dispatch();
|
||
}
|
||
/**
|
||
* 功能:仅推进传输和Process,不隐式执行动作或确认I帧。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:用例自行决定ACK/撤销的先后。
|
||
*/
|
||
static void flush(void)
|
||
{
|
||
unsigned i;
|
||
for (i = 0U; i < 4U; ++i) { poll(); CHECK(IEC104_SoftwareUpgrade_Process(upgrade)); }
|
||
refresh();
|
||
}
|
||
/**
|
||
* 功能:取得默认配置后选用构建矩阵指定的重启策略,使同组用例覆盖两种ACK约束。
|
||
* 输入参数:config——测试配置对象。
|
||
* 输出参数:config——测试配置对象。
|
||
* 返回值:无。
|
||
* 说明:本辅助入口用于构造或核对上述测试场景,相关状态保存在当前测试夹具中。
|
||
*/
|
||
static void defaults(IEC104_SoftwareUpgradeConfig_t *config)
|
||
{
|
||
IEC104_SoftwareUpgrade_Config_Default(config);
|
||
config->restart_policy = (IEC104_SoftwareUpgradeRestartPolicy_t)UPGRADE_TEST_POLICY;
|
||
}
|
||
/**
|
||
* 功能:清除所有注入和计数,创建两站点及升级模块,放宽链路期限后建立已STARTDT连接。
|
||
* 输入参数:options——可选升级服务配置(只读)。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。
|
||
*/
|
||
static void open_case(const IEC104_SoftwareUpgradeConfig_t *options)
|
||
{
|
||
IEC104_SlaveConfig_t config;
|
||
unsigned i;
|
||
++groups;
|
||
memset(&fake, 0, sizeof(fake)); memset(stations, 0, sizeof(stations));
|
||
memset(calls, 0, sizeof(calls)); memset(&last_receipt, 0, sizeof(last_receipt));
|
||
fake.now = 1000U; call_count = next_ns = executed = close_calls = send_calls = 0U;
|
||
decision = 1; send_override = ack_send_override = ack_override = check_override = -9;
|
||
status_error = status_mutation = close_error = reenter = stop_on_send = fatal_on_stop = 0;
|
||
ack_time = action_duration = 0U; business_now = UINT64_MAX;
|
||
slave = IEC104_Slave_Create(); CHECK(slave != NULL);
|
||
CHECK(IEC104_Slave_Add_Station(slave, &stations[0], 1U, NULL) == IEC104_STATION_OK);
|
||
CHECK(IEC104_Slave_Add_Station(slave, &stations[1], 2U, NULL) == IEC104_STATION_OK);
|
||
upgrade = IEC104_SoftwareUpgrade_Create(slave, options); CHECK(upgrade != NULL);
|
||
test_transport_config(&config);
|
||
config.protocol.link.k = IEC104_TCP_RECORD_CAPACITY;
|
||
config.protocol.link.t1_ms = config.protocol.link.t3_ms = 600000U;
|
||
config.protocol.local_send_timeout_ms = 600000U;
|
||
CHECK(IEC104_Slave_Init(slave, &config, NULL) == IEC104_TCP_OK);
|
||
sut = NULL;
|
||
for (i = 0U; i < IEC104_TCP_SERVER_CAPACITY; ++i) {
|
||
if (server_pool[i].in_use) { sut = &server_pool[i].server; break; }
|
||
}
|
||
CHECK(sut != NULL);
|
||
fake.accept_pending = 1U; poll(); push(start_act, sizeof(start_act)); poll();
|
||
refresh(); CHECK(status.active);
|
||
}
|
||
/**
|
||
* 功能:按公开退出契约先Cancel再Close,最后交付ABANDON。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:逐站检查可复用性以捕获引用泄漏。
|
||
*/
|
||
static void close_case(void)
|
||
{
|
||
unsigned i;
|
||
send_override = ack_send_override = ack_override = check_override = -9;
|
||
status_error = status_mutation = close_error = reenter = stop_on_send = fatal_on_stop = 0; action_duration = 0U;
|
||
IEC104_SoftwareUpgrade_Cancel(upgrade);
|
||
CHECK(IEC104_Slave_Close(slave, NULL) == IEC104_TCP_OK); dispatch();
|
||
for (i = 0U; i < 4U; ++i) {
|
||
refresh(); if (!status.abandon_pending) { break; }
|
||
CHECK(execute() == IEC104_SOFTWARE_UPGRADE_EXECUTE_OK);
|
||
}
|
||
CHECK(IEC104_SoftwareUpgrade_Destroy(upgrade));
|
||
for (i = 0U; i < 3U; ++i) {
|
||
if (IEC104_Station_Is_Registered(&stations[i])) {
|
||
CHECK(IEC104_Slave_Remove_Station(slave, &stations[i]) == IEC104_STATION_OK);
|
||
}
|
||
CHECK(IEC104_Station_Is_Reusable(&stations[i]));
|
||
}
|
||
CHECK(IEC104_Slave_Destroy(slave, NULL) == IEC104_TCP_OK);
|
||
}
|
||
/**
|
||
* 功能:请求携带当前va,刻意不自动确认新发出的结束确认,保留ACK竞争测试的控制权。
|
||
* 输入参数:bytes——报文字节缓冲区(只读);length——字节长度。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。
|
||
*/
|
||
static void queue_request(const uint8_t *bytes, size_t length)
|
||
{
|
||
uint8_t frame[255] = {0x68U};
|
||
CHECK(length <= 249U);
|
||
frame[1] = (uint8_t)(length + 4U);
|
||
frame[2] = (uint8_t)(next_ns << 1); frame[3] = (uint8_t)(next_ns >> 7); ++next_ns;
|
||
frame[4] = (uint8_t)(sut->connection.link_state.va << 1);
|
||
frame[5] = (uint8_t)(sut->connection.link_state.va >> 7);
|
||
memcpy(frame + 6U, bytes, length); push(frame, length + 6U);
|
||
}
|
||
/**
|
||
* 功能:将原始请求入队后立即推进传输并分派通知,暂不执行升级动作。
|
||
* 输入参数:bytes——报文字节缓冲区(只读);length——字节长度。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:本辅助入口用于构造或核对上述测试场景,相关状态保存在当前测试夹具中。
|
||
*/
|
||
static void request(const uint8_t *bytes, size_t length) { queue_request(bytes, length); poll(); }
|
||
/**
|
||
* 功能:从累计输出提取Type211的ASDU借用视图,结果指针和长度数组均须容纳64项。
|
||
* 输入参数:frames——按线上顺序排列的 ASDU 视图数组;lengths——各 ASDU 的长度数组。
|
||
* 输出参数:frames——按线上顺序排列的 ASDU 视图数组;lengths——各 ASDU 的长度数组。
|
||
* 返回值:本次收集或统计到的有效业务帧数量。
|
||
* 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。
|
||
*/
|
||
static unsigned collect(const uint8_t **frames, size_t *lengths)
|
||
{
|
||
size_t offset = 0U;
|
||
unsigned count = 0U;
|
||
while (offset < fake.sent_bytes) {
|
||
const uint8_t *frame = fake.output + offset;
|
||
size_t length = (size_t)frame[1] + 2U;
|
||
CHECK(length >= 6U && offset + length <= fake.sent_bytes);
|
||
if ((frame[2] & 1U) == 0U && frame[6] == 211U) {
|
||
CHECK(count < 64U); frames[count] = frame + 6U; lengths[count++] = length - 6U;
|
||
}
|
||
offset += length;
|
||
}
|
||
return count;
|
||
}
|
||
/**
|
||
* 功能:统计目前输出线上所有Type211的I帧,不消费或清除输出缓冲。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:本次收集或统计到的有效业务帧数量。
|
||
* 说明:本辅助入口用于构造或核对上述测试场景,相关状态保存在当前测试夹具中。
|
||
*/
|
||
static unsigned frame_count(void) { const uint8_t *frames[64]; size_t lengths[64]; return collect(frames, lengths); }
|
||
/**
|
||
* 功能:由输入原文独立构造期望确认。
|
||
* 输入参数:index——待访问或核对的条目下标;bytes——报文字节缓冲区(只读);length——字节长度;cot——完整传送原因字节;se_one——是否设置选择执行位。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:逐字节比较T/OA/VSQ/地址及CTYPE,而非只看COT。
|
||
*/
|
||
static void expect(unsigned index, const uint8_t *bytes, size_t length, uint8_t cot, bool se_one)
|
||
{
|
||
uint8_t expected[10]; const uint8_t *frames[64]; size_t lengths[64];
|
||
unsigned count = collect(frames, lengths);
|
||
if (length > 10U) { length = 10U; }
|
||
memcpy(expected, bytes, length); expected[2] = (uint8_t)(cot | (bytes[2] & 0x80U));
|
||
if (se_one && length >= 10U) { expected[9] |= 0x80U; }
|
||
if (count <= index || lengths[index] != length || memcmp(frames[index], expected, length) != 0) {
|
||
fprintf(stderr, "group=%u frame=%u count=%u expected_cot=%u\n", groups, index, count, cot);
|
||
}
|
||
CHECK(count > index && lengths[index] == length && memcmp(frames[index], expected, length) == 0);
|
||
}
|
||
/**
|
||
* 功能:有未确认发送记录时注入截至V(S)的累计ACK并分派通知,ACK裁决由后续业务推进。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:本辅助入口用于构造或核对上述测试场景,相关状态保存在当前测试夹具中。
|
||
*/
|
||
static void ack_all(void)
|
||
{
|
||
if (sut->connection.link_state.vs != sut->connection.link_state.va) { push_ack(sut->connection.link_state.vs); poll(); }
|
||
}
|
||
/**
|
||
* 功能:直接统计真实TCP实例中仍占用的ACK观察槽,捕获回执泄漏和重复分配。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:当前占用的 ACK 观察槽数量。
|
||
* 说明:本辅助入口用于构造或核对上述测试场景,相关状态保存在当前测试夹具中。
|
||
*/
|
||
static unsigned watches(void)
|
||
{
|
||
unsigned i, count = 0U;
|
||
for (i = 0U; i < IEC104_TCP_ACK_WATCH_CAPACITY; ++i) { if (sut->ack_watches[i].ticket != 0U) { ++count; } }
|
||
return count;
|
||
}
|
||
/**
|
||
* 功能:发送START并执行一次应用动作,排出确认后断言真实升级会话已打开。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。
|
||
*/
|
||
static void start_session(void)
|
||
{
|
||
request(start_request, sizeof(start_request)); CHECK(execute() == IEC104_SOFTWARE_UPGRADE_EXECUTE_OK);
|
||
flush(); CHECK(status.session_state == IEC104_SOFTWARE_UPGRADE_SESSION_OPEN);
|
||
}
|
||
/**
|
||
* 功能:发送END并执行应用动作,排出确认后保持未ACK,断言会话等待确认且仅占一个观察槽。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。
|
||
*/
|
||
static void end_session(void)
|
||
{
|
||
request(end_request, sizeof(end_request)); CHECK(execute() == IEC104_SOFTWARE_UPGRADE_EXECUTE_OK);
|
||
flush(); CHECK(status.session_state == IEC104_SOFTWARE_UPGRADE_SESSION_WAIT_ACK && watches() == 1U);
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:绑定唯一性、空参数及已撤回的策略数值2。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:失败不能消耗可重建的池槽。
|
||
*/
|
||
static void test_create(void)
|
||
{
|
||
IEC104_SoftwareUpgradeConfig_t c;
|
||
defaults(&c); open_case(&c);
|
||
CHECK(IEC104_SoftwareUpgrade_Create(slave, &c) == NULL);
|
||
CHECK(IEC104_SoftwareUpgrade_Create(NULL, &c) == NULL);
|
||
CHECK(IEC104_SoftwareUpgrade_Create(slave, NULL) == NULL);
|
||
CHECK(IEC104_SoftwareUpgrade_Execute_Next(upgrade, NULL, NULL) == IEC104_SOFTWARE_UPGRADE_EXECUTE_ERROR);
|
||
CHECK(IEC104_SoftwareUpgrade_Destroy(upgrade));
|
||
c.restart_policy = (IEC104_SoftwareUpgradeRestartPolicy_t)2;
|
||
CHECK(IEC104_SoftwareUpgrade_Create(slave, &c) == NULL);
|
||
c.restart_policy = (IEC104_SoftwareUpgradeRestartPolicy_t)-1;
|
||
CHECK(IEC104_SoftwareUpgrade_Create(slave, &c) == NULL);
|
||
defaults(&c); upgrade = IEC104_SoftwareUpgrade_Create(slave, &c); CHECK(upgrade != NULL);
|
||
close_case();
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:校验优先级故意叠加多个错误。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:另测截短/超长、兼容开关和未定义位镜像。
|
||
* 非211只验证不接手;未知类型44兜底属于应用,不能由本模块代发。
|
||
*/
|
||
static void test_validation(void)
|
||
{
|
||
unsigned mode;
|
||
for (mode = 0U; mode < 22U; ++mode) {
|
||
IEC104_SoftwareUpgradeConfig_t c;
|
||
uint8_t bytes[11]; size_t length = 10U; uint8_t cot = 0x47U; bool legal = false;
|
||
defaults(&c); memcpy(bytes, start_request, 10U); bytes[10] = 0xa5U;
|
||
switch (mode) {
|
||
case 0: legal = true; cot = 7U; break;
|
||
case 1: bytes[2] = 10U; bytes[4] = 99U; c.check_ioa = true; cot = 0x6dU; break;
|
||
case 2: bytes[4] = 99U; c.check_ioa = true; cot = 0x6eU; break;
|
||
case 3: bytes[4] = bytes[5] = 255U; cot = 0x6eU; break;
|
||
case 4: c.check_ioa = true; bytes[1] = 2U; cot = 0x6fU; break;
|
||
case 5: bytes[1] = 1U; break;
|
||
case 6: bytes[1] = 1U; c.accept_vsq_one = true; legal = true; cot = 7U; break;
|
||
case 7: bytes[1] = 2U; c.accept_vsq_one = true; break;
|
||
case 8: bytes[1] = 0x80U; break;
|
||
case 9: bytes[1] = 0x81U; c.accept_vsq_one = true; break;
|
||
case 10: bytes[2] |= 0x40U; break;
|
||
case 11: bytes[2] = 8U; cot = 0x49U; break;
|
||
case 12: length = 6U; break;
|
||
case 13: length = 7U; c.check_ioa = true; break;
|
||
case 14: length = 8U; c.check_ioa = true; break;
|
||
case 15: length = 9U; break;
|
||
case 16: length = 9U; c.check_ioa = true; cot = 0x6fU; break;
|
||
case 17: length = 11U; break;
|
||
case 18: bytes[2] |= 0x80U; legal = true; cot = 7U; break;
|
||
case 19: bytes[0] = 212U; break;
|
||
case 20: c.check_ioa = true; bytes[6] = bytes[7] = bytes[8] = 0U; legal = true; cot = 7U; break;
|
||
default: memcpy(bytes, end_request, 10U); bytes[1] = 2U; c.end_confirm_se_one = true; break;
|
||
}
|
||
open_case(&c); request(bytes, length);
|
||
if (mode == 19U) { flush(); CHECK(frame_count() == 0U && call_count == 0U); close_case(); continue; }
|
||
if (legal) { CHECK(execute() == IEC104_SOFTWARE_UPGRADE_EXECUTE_OK); }
|
||
flush(); expect(0U, bytes, length, cot, c.end_confirm_se_one);
|
||
CHECK(frame_count() == 1U);
|
||
CHECK(call_count == (legal && (bytes[2] & 0x80U) == 0U ? 1U : 0U));
|
||
if (call_count != 0U) { CHECK(calls[0].ioa == (c.check_ioa ? 0U : 0x123456U) && calls[0].ctype == 0x95U); }
|
||
close_case();
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:同CA重启必须分两次Execute交付旧ABANDON和新START。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:无会话撤销不调用动作。
|
||
* 拒绝END/CANCEL保持OPEN,WAIT_ACK与READY的撤销结果分别验证。
|
||
*/
|
||
static void test_session_table(void)
|
||
{
|
||
unsigned mode;
|
||
for (mode = 0U; mode < 11U; ++mode) {
|
||
IEC104_SoftwareUpgradeConfig_t c;
|
||
uint8_t bytes[10]; unsigned before; uint8_t cot = 0x47U;
|
||
defaults(&c); open_case(&c);
|
||
if (mode != 0U && mode != 1U) { start_session(); }
|
||
before = call_count;
|
||
if (mode == 0U || mode == 3U || mode == 4U || mode == 10U) { memcpy(bytes, end_request, 10U); }
|
||
else if (mode == 2U || mode == 5U) { memcpy(bytes, start_request, 10U); }
|
||
else { memcpy(bytes, cancel_request, 10U); }
|
||
if (mode == 4U || mode == 5U || mode == 6U) { bytes[4] = 2U; }
|
||
if (mode == 3U || mode == 7U) { decision = 0; }
|
||
if (mode == 8U || mode == 9U || mode == 10U) { end_session(); before = call_count; }
|
||
if (mode == 9U) { ack_all(); flush(); CHECK(status.restart_ready); }
|
||
request(bytes, sizeof(bytes)); CHECK(execute() == IEC104_SOFTWARE_UPGRADE_EXECUTE_OK);
|
||
if (mode == 2U) {
|
||
CHECK(call_count == before + 1U && calls[before].operation == IEC104_SOFTWARE_UPGRADE_OP_ABANDON);
|
||
CHECK(calls[before].reason == IEC104_SOFTWARE_UPGRADE_ABANDON_SUPERSEDED);
|
||
CHECK(calls[before].receive_serial == calls[0].receive_serial && calls[before].ctype == calls[0].ctype);
|
||
CHECK(execute() == IEC104_SOFTWARE_UPGRADE_EXECUTE_OK); cot = 7U;
|
||
} else if (mode == 1U || mode == 6U || mode == 8U) { cot = 9U; }
|
||
else if (mode == 7U || mode == 9U) { cot = 0x49U; }
|
||
flush(); expect(frame_count() - 1U, bytes, sizeof(bytes), cot, false);
|
||
if (mode == 0U || mode == 1U || mode == 4U || mode == 5U || mode == 6U || mode == 9U || mode == 10U) {
|
||
CHECK(call_count == before);
|
||
}
|
||
if (mode == 2U) { CHECK(status.session_serial == 2U && calls[before + 1U].session_serial == 2U); }
|
||
if (mode == 3U || mode == 7U) { CHECK(status.session_state == IEC104_SOFTWARE_UPGRADE_SESSION_OPEN); }
|
||
if (mode == 8U) { CHECK(status.session_state == IEC104_SOFTWARE_UPGRADE_SESSION_NONE && watches() == 0U); }
|
||
close_case();
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:把ACK到达时刻与Process运行时刻分开:按时历史ACK可迟处理,等于期限仍到期。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:领取失败的输出保持原值;已确定授权可在STOP/断开后凭原身份恰好领取一次。
|
||
*/
|
||
static void test_ack_and_take(void)
|
||
{
|
||
unsigned mode;
|
||
for (mode = 0U; mode < 8U; ++mode) {
|
||
IEC104_SoftwareUpgradeConfig_t c;
|
||
IEC104_SoftwareUpgradeRequest_t out, untouched;
|
||
defaults(&c); c.restart_ack_timeout_ms = 50U; c.end_confirm_se_one = mode == 7U;
|
||
open_case(&c); start_session(); end_session();
|
||
expect(1U, end_request, sizeof(end_request), 7U, c.end_confirm_se_one);
|
||
CHECK(!status.restart_ready); memset(&out, 0xa5, sizeof(out)); untouched = out;
|
||
CHECK(!IEC104_SoftwareUpgrade_Take_Restart(upgrade, &out) && memcmp(&out, &untouched, sizeof(out)) == 0);
|
||
if (mode == 1U) { fake.now = 1049U; ack_all(); fake.now = 1100U; }
|
||
else if (mode == 2U) { fake.now = 1050U; ack_all(); }
|
||
else if (mode == 3U) { ack_override = IEC104_SLAVE_ACK_ACKED; ack_time = 999U; }
|
||
else if (mode == 4U) { fake.now = 1050U; }
|
||
else { ack_all(); }
|
||
CHECK(IEC104_SoftwareUpgrade_Process(upgrade)); refresh();
|
||
if (mode == 2U || mode == 3U || mode == 4U) {
|
||
CHECK(!status.restart_ready && status.abandon_pending && status.ack_timeouts == 1U && watches() == 0U);
|
||
CHECK(execute() == IEC104_SOFTWARE_UPGRADE_EXECUTE_OK);
|
||
CHECK(calls[2].reason == IEC104_SOFTWARE_UPGRADE_ABANDON_ACK_TIMEOUT);
|
||
CHECK(frame_count() == 2U);
|
||
} else {
|
||
CHECK(status.restart_ready && watches() == 0U);
|
||
if (mode == 5U) {
|
||
check_override = IEC104_SLAVE_REQUEST_WAIT_EVENTS;
|
||
CHECK(!IEC104_SoftwareUpgrade_Take_Restart(upgrade, &out));
|
||
CHECK(memcmp(&out, &untouched, sizeof(out)) == 0);
|
||
check_override = IEC104_SLAVE_REQUEST_ERROR;
|
||
CHECK(!IEC104_SoftwareUpgrade_Take_Restart(upgrade, &out));
|
||
check_override = -9;
|
||
}
|
||
if (mode == 6U) { push(stop_act, sizeof(stop_act)); poll(); fake.recv_eof = 1U; poll(); }
|
||
CHECK(IEC104_SoftwareUpgrade_Take_Restart(upgrade, &out));
|
||
CHECK(out.operation == IEC104_SOFTWARE_UPGRADE_OP_END && out.ctype == end_request[9]);
|
||
CHECK(out.identity.generation == calls[0].identity.generation && out.session_serial == 1U);
|
||
CHECK(!IEC104_SoftwareUpgrade_Take_Restart(upgrade, &out));
|
||
}
|
||
close_case();
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:结束确认先发出,STOP先于累计ACK:ACKED允许排空期ACK,ACTIVE_ACKED就此失效。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。
|
||
*/
|
||
static void test_stop_policy(void)
|
||
{
|
||
IEC104_SoftwareUpgradeConfig_t c;
|
||
defaults(&c); open_case(&c); start_session(); end_session();
|
||
push(stop_act, sizeof(stop_act)); poll(); refresh();
|
||
if (UPGRADE_TEST_POLICY == 0) {
|
||
CHECK(status.ack_pending && !status.restart_ready && !status.abandon_pending);
|
||
CHECK(!status.need_process); /* 允许保留的STALE观察不应让事件循环持续零等待。 */
|
||
CHECK(IEC104_SoftwareUpgrade_Process(upgrade)); ack_all();
|
||
CHECK(IEC104_SoftwareUpgrade_Process(upgrade)); refresh(); CHECK(status.restart_ready);
|
||
} else {
|
||
CHECK(status.abandon_pending && !status.restart_ready);
|
||
CHECK(execute() == IEC104_SOFTWARE_UPGRADE_EXECUTE_OK);
|
||
CHECK(calls[2].reason == IEC104_SOFTWARE_UPGRADE_ABANDON_ACK_LOST);
|
||
ack_all(); CHECK(IEC104_SoftwareUpgrade_Process(upgrade)); refresh(); CHECK(!status.restart_ready);
|
||
}
|
||
close_case();
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:不靠相同毫秒值推断网络先后。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:执行撤销前刷新已存在ACK,撤销先接受则迟到ACK无效。
|
||
*/
|
||
static void test_ack_cancel_race(void)
|
||
{
|
||
unsigned mode;
|
||
for (mode = 0U; mode < 3U; ++mode) {
|
||
IEC104_SoftwareUpgradeConfig_t c;
|
||
defaults(&c); open_case(&c); start_session(); end_session();
|
||
if (mode == 0U) { ack_all(); }
|
||
request(cancel_request, sizeof(cancel_request));
|
||
CHECK(execute() == IEC104_SOFTWARE_UPGRADE_EXECUTE_OK); /* 故意省略前置Process,Execute须刷新ACK。 */
|
||
flush(); expect(2U, cancel_request, sizeof(cancel_request), mode == 0U ? 0x49U : 9U, false);
|
||
CHECK(call_count == (mode == 0U ? 2U : 3U));
|
||
if (mode != 0U) { ack_all(); flush(); CHECK(!status.restart_ready); }
|
||
if (mode == 2U) { IEC104_SoftwareUpgrade_Cancel(upgrade); refresh(); CHECK(!status.abandon_pending); }
|
||
close_case();
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:TEST只模拟会话,不调用动作、不占ACK槽。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:真实READY也属于排斥TEST的真实会话。
|
||
*/
|
||
static void test_test_domain(void)
|
||
{
|
||
unsigned mode;
|
||
for (mode = 0U; mode < 8U; ++mode) {
|
||
IEC104_SoftwareUpgradeConfig_t c;
|
||
uint8_t bytes[10]; unsigned before;
|
||
defaults(&c); open_case(&c);
|
||
if (mode == 5U || mode == 6U || mode == 7U) {
|
||
start_session(); if (mode != 5U) { end_session(); }
|
||
if (mode == 7U) { ack_all(); flush(); }
|
||
}
|
||
memcpy(bytes, start_request, 10U); bytes[2] |= 0x80U;
|
||
request(bytes, 10U); CHECK(execute() == IEC104_SOFTWARE_UPGRADE_EXECUTE_OK); flush();
|
||
before = call_count;
|
||
if (mode >= 5U) { CHECK(!status.session_test); expect(frame_count() - 1U, bytes, 10U, 0x47U, false); }
|
||
else {
|
||
CHECK(status.session_test && !IEC104_SoftwareUpgrade_Destroy(upgrade));
|
||
if (mode == 0U) { bytes[4] = 2U; }
|
||
else if (mode == 1U) { /* 同CA重新开启模拟会话。 */ }
|
||
else if (mode == 2U) { memcpy(bytes, end_request, 10U); bytes[2] |= 0x80U; }
|
||
else if (mode == 3U) { memcpy(bytes, cancel_request, 10U); bytes[2] |= 0x80U; }
|
||
else { memcpy(bytes, end_request, 10U); }
|
||
request(bytes, 10U); CHECK(execute() == IEC104_SOFTWARE_UPGRADE_EXECUTE_OK); flush();
|
||
CHECK(status.session_test == (mode <= 1U));
|
||
CHECK(call_count == 0U && watches() == 0U && !status.restart_ready);
|
||
if (mode == 0U || mode == 4U) { expect(1U, bytes, 10U, 0x47U, false); }
|
||
}
|
||
CHECK(call_count == before); close_case();
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:分别拉动执行、普通回复、会话及ACK四条期限。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:覆盖边界相等、业务时钟回退和0禁用。
|
||
* 未交出的END肯定可改否定;普通回复超时关闭原连接,已执行动作不能被重做。
|
||
*/
|
||
static void test_timeouts_and_wait(void)
|
||
{
|
||
unsigned mode;
|
||
for (mode = 0U; mode < 8U; ++mode) {
|
||
IEC104_SoftwareUpgradeConfig_t c;
|
||
defaults(&c); c.execute_timeout_ms = 10U; c.reply_timeout_ms = 20U;
|
||
c.session_timeout_ms = 30U; c.restart_ack_timeout_ms = 40U;
|
||
if (mode == 7U) { c.execute_timeout_ms = c.reply_timeout_ms = c.session_timeout_ms = c.restart_ack_timeout_ms = 0U; }
|
||
open_case(&c);
|
||
if (mode <= 1U) {
|
||
request(start_request, sizeof(start_request));
|
||
if (mode == 0U) { fake.now = 1010U; } else { business_now = 999U; }
|
||
CHECK(execute() == IEC104_SOFTWARE_UPGRADE_EXECUTE_OK); flush();
|
||
CHECK(call_count == 0U && status.timeouts == 1U); expect(0U, start_request, 10U, 0x47U, false);
|
||
} else if (mode == 2U) {
|
||
start_session(); fake.now = 1030U; CHECK(IEC104_SoftwareUpgrade_Process(upgrade)); refresh();
|
||
CHECK(status.abandon_pending && status.session_timeouts == 1U);
|
||
CHECK(execute() == IEC104_SOFTWARE_UPGRADE_EXECUTE_OK);
|
||
CHECK(calls[1].reason == IEC104_SOFTWARE_UPGRADE_ABANDON_SESSION_TIMEOUT);
|
||
CHECK(calls[1].ioa == calls[0].ioa && calls[1].accepted_ms == calls[0].accepted_ms);
|
||
} else if (mode == 3U) {
|
||
send_override = IEC104_TCP_SUBMIT_WAIT;
|
||
request(start_request, 10U); CHECK(execute() == IEC104_SOFTWARE_UPGRADE_EXECUTE_OK);
|
||
fake.now = 1020U; CHECK(IEC104_SoftwareUpgrade_Process(upgrade)); refresh();
|
||
CHECK(close_calls == 1U && status.reply_timeouts == 1U && status.abandon_pending);
|
||
} else if (mode == 4U) {
|
||
start_session(); ack_send_override = IEC104_TCP_SUBMIT_WAIT;
|
||
request(end_request, 10U); CHECK(execute() == IEC104_SOFTWARE_UPGRADE_EXECUTE_OK);
|
||
fake.now = 1040U; CHECK(IEC104_SoftwareUpgrade_Process(upgrade));
|
||
ack_send_override = -9; flush(); CHECK(status.abandon_pending && status.ack_timeouts == 1U);
|
||
expect(1U, end_request, 10U, 0x47U, false);
|
||
} else if (mode == 5U) {
|
||
/* 会话先到期只改写尚未交出的START肯定,不能重置普通回复的起算点。 */
|
||
c.reply_timeout_ms = 100U; close_case(); open_case(&c);
|
||
send_override = IEC104_TCP_SUBMIT_WAIT; request(start_request, 10U); CHECK(execute() == IEC104_SOFTWARE_UPGRADE_EXECUTE_OK);
|
||
fake.now = 1030U; CHECK(IEC104_SoftwareUpgrade_Process(upgrade));
|
||
send_override = -9; flush(); expect(0U, start_request, 10U, 0x47U, false);
|
||
} else if (mode == 6U) {
|
||
start_session(); action_duration = 40U;
|
||
request(end_request, 10U); CHECK(execute() == IEC104_SOFTWARE_UPGRADE_EXECUTE_OK);
|
||
action_duration = 0U; flush(); CHECK(status.ack_timeouts == 1U);
|
||
expect(1U, end_request, 10U, 0x47U, false);
|
||
} else {
|
||
request(start_request, 10U); fake.now = 100000U; CHECK(execute() == IEC104_SOFTWARE_UPGRADE_EXECUTE_OK);
|
||
flush(); CHECK(status.session_active && status.timeouts == 0U);
|
||
}
|
||
close_case();
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:槽满丢新。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:移除并重注册同CA不能接续旧站会话。真实/TEST引用均须在各自结局归还。
|
||
* 双槽配置另证明END肯定未交出时,排在后面的撤销不能越过FIFO先执行。
|
||
*/
|
||
static void test_fifo_and_references(void)
|
||
{
|
||
IEC104_SoftwareUpgradeConfig_t c;
|
||
uint8_t bytes[10]; unsigned i;
|
||
defaults(&c); open_case(&c);
|
||
for (i = 0U; i < IEC104_SOFTWARE_UPGRADE_TASK_CAPACITY + 1U; ++i) { queue_request(start_request, 10U); }
|
||
poll(); refresh(); CHECK(status.pending_requests == IEC104_SOFTWARE_UPGRADE_TASK_CAPACITY && status.dropped_requests == 1U);
|
||
close_case();
|
||
|
||
open_case(&c); start_session();
|
||
CHECK(IEC104_Slave_Remove_Station(slave, &stations[0]) == IEC104_STATION_OK);
|
||
CHECK(!IEC104_Station_Is_Reusable(&stations[0]));
|
||
CHECK(IEC104_Slave_Add_Station(slave, &stations[2], 1U, NULL) == IEC104_STATION_OK);
|
||
request(end_request, 10U); CHECK(execute() == IEC104_SOFTWARE_UPGRADE_EXECUTE_OK); flush();
|
||
CHECK(call_count == 1U); expect(1U, end_request, 10U, 0x47U, false);
|
||
IEC104_SoftwareUpgrade_Cancel(upgrade); CHECK(execute() == IEC104_SOFTWARE_UPGRADE_EXECUTE_OK);
|
||
CHECK(calls[1].station_id == calls[0].station_id && IEC104_Station_Is_Reusable(&stations[0])); close_case();
|
||
|
||
open_case(&c); memcpy(bytes, start_request, 10U); bytes[2] |= 0x80U;
|
||
request(bytes, 10U); CHECK(execute() == IEC104_SOFTWARE_UPGRADE_EXECUTE_OK); flush();
|
||
CHECK(IEC104_Slave_Remove_Station(slave, &stations[0]) == IEC104_STATION_OK);
|
||
CHECK(!IEC104_Station_Is_Reusable(&stations[0]));
|
||
IEC104_SoftwareUpgrade_Cancel(upgrade); CHECK(IEC104_Station_Is_Reusable(&stations[0])); close_case();
|
||
|
||
#if IEC104_SOFTWARE_UPGRADE_TASK_CAPACITY > 1U
|
||
open_case(&c); start_session(); ack_send_override = IEC104_TCP_SUBMIT_WAIT;
|
||
request(end_request, 10U); CHECK(execute() == IEC104_SOFTWARE_UPGRADE_EXECUTE_OK);
|
||
request(cancel_request, 10U); CHECK(execute() == IEC104_SOFTWARE_UPGRADE_EXECUTE_EMPTY);
|
||
CHECK(call_count == 2U); ack_send_override = -9; flush();
|
||
CHECK(execute() == IEC104_SOFTWARE_UPGRADE_EXECUTE_OK); flush();
|
||
expect(1U, end_request, 10U, 7U, false); expect(2U, cancel_request, 10U, 9U, false);
|
||
CHECK(!status.restart_ready && watches() == 0U); close_case();
|
||
#endif
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:查询/发送/关闭故障进入粘滞停用。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:重复Process不重复发送或关闭,不保留忙轮询计时器。
|
||
* 正常STOP让出与回调重入是独立分支,不应误报faulted。
|
||
*/
|
||
static void test_faults(void)
|
||
{
|
||
unsigned mode;
|
||
for (mode = 0U; mode < 8U; ++mode) {
|
||
IEC104_SoftwareUpgradeConfig_t c;
|
||
unsigned sent_before, closes_before;
|
||
defaults(&c); c.reply_timeout_ms = 10U; open_case(&c);
|
||
if (mode == 0U || mode == 1U) {
|
||
send_override = mode == 0U ? IEC104_TCP_SUBMIT_ERROR : IEC104_TCP_SUBMIT_FATAL;
|
||
request(start_request, 10U); CHECK(execute() == IEC104_SOFTWARE_UPGRADE_EXECUTE_OK);
|
||
} else if (mode == 2U || mode == 3U) {
|
||
start_session(); end_session();
|
||
if (mode == 2U) { ack_override = IEC104_SLAVE_ACK_ERROR; }
|
||
else { CHECK(IEC104_Slave_Close(slave, NULL) == IEC104_TCP_OK); }
|
||
{ IEC104_SoftwareUpgradeStatus_t out, before;
|
||
memset(&out, 0xa5, sizeof(out)); before = out;
|
||
CHECK(!IEC104_SoftwareUpgrade_Get_Status(upgrade, &out)); CHECK(memcmp(&out, &before, sizeof(out)) == 0); }
|
||
} else if (mode == 4U) {
|
||
request(start_request, 10U); check_override = IEC104_SLAVE_REQUEST_ERROR;
|
||
CHECK(execute() == IEC104_SOFTWARE_UPGRADE_EXECUTE_ERROR); check_override = -9;
|
||
} else if (mode == 5U) {
|
||
send_override = IEC104_TCP_SUBMIT_WAIT; close_error = 1;
|
||
request(start_request, 10U); CHECK(execute() == IEC104_SOFTWARE_UPGRADE_EXECUTE_OK); fake.now += 10U;
|
||
} else if (mode == 6U) {
|
||
stop_on_send = 1; request(start_request, 10U); CHECK(execute() == IEC104_SOFTWARE_UPGRADE_EXECUTE_OK);
|
||
dispatch(); CHECK(IEC104_SoftwareUpgrade_Process(upgrade)); refresh(); CHECK(!status.faulted);
|
||
close_case(); continue;
|
||
} else {
|
||
reenter = 1; request(start_request, 10U); CHECK(execute() == IEC104_SOFTWARE_UPGRADE_EXECUTE_OK);
|
||
reenter = 0; flush(); CHECK(!status.faulted && call_count == 1U); close_case(); continue;
|
||
}
|
||
CHECK(!IEC104_SoftwareUpgrade_Process(upgrade));
|
||
ack_override = check_override = -9; status_error = 0;
|
||
refresh(); CHECK(status.faulted && !status.need_process && !status.timer_active);
|
||
sent_before = send_calls; closes_before = close_calls;
|
||
CHECK(!IEC104_SoftwareUpgrade_Process(upgrade)); CHECK(!IEC104_SoftwareUpgrade_Process(upgrade));
|
||
CHECK(send_calls == sent_before && close_calls == closes_before);
|
||
if (mode == 0U) {
|
||
send_override = -9; request(start_request, 10U); refresh();
|
||
CHECK(status.faulted_dropped == 1U && call_count == 1U && frame_count() == 0U);
|
||
}
|
||
close_case();
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 功能:逐项取反完整STOP判据。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:即使未读STOP仍在,FATAL也必须按故障收尾。
|
||
*/
|
||
static void test_defer_stop_predicates(void)
|
||
{
|
||
unsigned mode;
|
||
for (mode = 1U; mode <= 10U; ++mode) {
|
||
IEC104_SoftwareUpgradeConfig_t c;
|
||
defaults(&c); open_case(&c);
|
||
status_mutation = (int)mode;
|
||
if (mode == 9U) { status_error = 1; }
|
||
if (mode == 10U) { fatal_on_stop = 1; }
|
||
stop_on_send = 1; request(start_request, 10U);
|
||
CHECK(execute() == IEC104_SOFTWARE_UPGRADE_EXECUTE_OK);
|
||
CHECK(!IEC104_SoftwareUpgrade_Process(upgrade));
|
||
status_error = status_mutation = 0; refresh();
|
||
CHECK(status.faulted && status.send_errors == 1U && status.abandon_pending);
|
||
CHECK(call_count == 1U);
|
||
close_case();
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:用另一确认占住ACK槽,单独施加观察容量背压。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:释放后重试原确认而不再调用END。
|
||
* 这里只模拟共享槽资源,不把占槽报文冒充系统命令的完整QRP1流程。
|
||
*/
|
||
static void test_observer_capacity(void)
|
||
{
|
||
IEC104_SoftwareUpgradeConfig_t c;
|
||
IEC104_SlaveEventIdentity_t id;
|
||
IEC104_SlaveAckReceipt_t occupied;
|
||
IEC60870_Asdu_t borrowed;
|
||
uint8_t other[] = {200U,0U,7U,0U,1U,0U,0U,0U,0U};
|
||
defaults(&c); open_case(&c); start_session();
|
||
CHECK(IEC104_Slave_Get_Event_Identity(slave, &input_event, &id));
|
||
CHECK(IEC60870_Asdu_Create_From_Buffer(&borrowed, IEC104_Slave_Get_Application_Layer_Parameters(slave),
|
||
other, sizeof(other)) == IEC60870_ASDU_OK);
|
||
CHECK(IEC104_Slave_Send_Response_Acked(slave, &id, &borrowed, &occupied) == IEC104_TCP_SUBMIT_OK);
|
||
request(end_request, 10U); CHECK(execute() == IEC104_SOFTWARE_UPGRADE_EXECUTE_OK); flush();
|
||
#if IEC104_TCP_ACK_WATCH_CAPACITY == 1U
|
||
CHECK(status.ack_pending && status.pending_requests == 1U && !status.need_process && !status.restart_ready);
|
||
CHECK(frame_count() == 1U && call_count == 2U);
|
||
#endif
|
||
IEC104_Slave_Release_Ack(slave, &occupied); flush();
|
||
CHECK(frame_count() == 2U && call_count == 2U && status.pending_requests == 0U);
|
||
ack_all(); flush(); CHECK(status.restart_ready); close_case();
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:非ACCEPT返回不消耗会话序号。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:只有合法且未到期的真实队首请求才能抢占TEST。
|
||
*/
|
||
static void test_test_preemption_and_rejected_start(void)
|
||
{
|
||
IEC104_SoftwareUpgradeConfig_t c;
|
||
uint8_t bytes[10];
|
||
defaults(&c); c.execute_timeout_ms = 10U;
|
||
open_case(&c); decision = 99;
|
||
request(start_request, 10U); CHECK(execute() == IEC104_SOFTWARE_UPGRADE_EXECUTE_OK); flush();
|
||
CHECK(status.session_state == IEC104_SOFTWARE_UPGRADE_SESSION_NONE);
|
||
decision = 1; start_session(); CHECK(status.session_serial == 1U);
|
||
close_case();
|
||
|
||
open_case(&c); memcpy(bytes, start_request, 10U); bytes[2] |= 0x80U;
|
||
request(bytes, 10U); CHECK(execute() == IEC104_SOFTWARE_UPGRADE_EXECUTE_OK); flush(); CHECK(status.session_test);
|
||
memcpy(bytes, start_request, 10U); bytes[1] = 2U;
|
||
request(bytes, 10U); flush(); CHECK(status.session_test && call_count == 0U);
|
||
request(start_request, 10U); fake.now += 10U;
|
||
CHECK(execute() == IEC104_SOFTWARE_UPGRADE_EXECUTE_OK); flush(); CHECK(status.session_test && call_count == 0U);
|
||
request(start_request, 10U); CHECK(execute() == IEC104_SOFTWARE_UPGRADE_EXECUTE_OK); flush();
|
||
CHECK(!status.session_test && status.session_active && call_count == 1U);
|
||
close_case();
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:WAIT只代表仍有待执行动作受通知排序阻挡。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:空队列/待回复队首仍为EMPTY。
|
||
* 显式Cancel可放弃READY,ABANDON须携带原START字段,之后不得再领取旧授权。
|
||
*/
|
||
static void test_pending_notifications_and_cancel_ready(void)
|
||
{
|
||
IEC104_SoftwareUpgradeConfig_t c;
|
||
IEC104_SoftwareUpgradeRequest_t out, saved;
|
||
defaults(&c); open_case(&c);
|
||
push(stop_act, sizeof(stop_act)); CHECK(IEC104_Slave_Poll(slave, 0U, NULL) == IEC104_TCP_OK);
|
||
CHECK(execute() == IEC104_SOFTWARE_UPGRADE_EXECUTE_EMPTY && call_count == 0U);
|
||
dispatch(); close_case();
|
||
|
||
open_case(&c); send_override = IEC104_TCP_SUBMIT_WAIT;
|
||
request(start_request, 10U); CHECK(execute() == IEC104_SOFTWARE_UPGRADE_EXECUTE_OK);
|
||
push(stop_act, sizeof(stop_act)); CHECK(IEC104_Slave_Poll(slave, 0U, NULL) == IEC104_TCP_OK);
|
||
CHECK(execute() == IEC104_SOFTWARE_UPGRADE_EXECUTE_EMPTY && call_count == 1U);
|
||
dispatch(); close_case();
|
||
|
||
open_case(&c);
|
||
request(start_request, 10U);
|
||
push(stop_act, sizeof(stop_act)); CHECK(IEC104_Slave_Poll(slave, 0U, NULL) == IEC104_TCP_OK);
|
||
CHECK(execute() == IEC104_SOFTWARE_UPGRADE_EXECUTE_WAIT && call_count == 0U);
|
||
dispatch(); refresh(); CHECK(status.pending_requests == 0U && !status.session_active); close_case();
|
||
|
||
open_case(&c); start_session(); end_session(); ack_all(); flush(); CHECK(status.restart_ready);
|
||
IEC104_SoftwareUpgrade_Cancel(upgrade); refresh(); CHECK(!status.restart_ready && status.abandon_pending);
|
||
CHECK(execute() == IEC104_SOFTWARE_UPGRADE_EXECUTE_OK);
|
||
CHECK(calls[2].operation == IEC104_SOFTWARE_UPGRADE_OP_ABANDON);
|
||
CHECK(calls[2].receive_serial == calls[0].receive_serial && calls[2].originator_address == calls[0].originator_address);
|
||
CHECK(calls[2].reason == IEC104_SOFTWARE_UPGRADE_ABANDON_CANCELLED);
|
||
memset(&out, 0x69, sizeof(out)); saved = out;
|
||
CHECK(!IEC104_SoftwareUpgrade_Take_Restart(upgrade, &out) && memcmp(&out, &saved, sizeof(out)) == 0);
|
||
close_case();
|
||
}
|
||
|
||
/**
|
||
* 功能:运行Type211会话、ACK策略、时钟期限、引用与故障注入用例,汇总当前构建配置结果。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:正常完成返回 0;参数、运行或断言失败以非零状态结束进程。
|
||
* 说明:本辅助入口用于构造或核对上述测试场景,相关状态保存在当前测试夹具中。
|
||
*/
|
||
int main(void)
|
||
{
|
||
test_create(); test_validation(); test_session_table(); test_ack_and_take(); test_stop_policy();
|
||
test_ack_cancel_race(); test_test_domain(); test_timeouts_and_wait(); test_fifo_and_references(); test_faults();
|
||
test_observer_capacity(); test_test_preemption_and_rejected_start(); test_pending_notifications_and_cancel_ready();
|
||
test_defer_stop_predicates();
|
||
printf("SoftwareUpgrade: %u groups passed (TCP=%u TASK=%u POLICY=%u)\n", groups,
|
||
(unsigned)IEC104_TCP_SERVER_CAPACITY, (unsigned)IEC104_SOFTWARE_UPGRADE_TASK_CAPACITY, (unsigned)UPGRADE_TEST_POLICY);
|
||
return 0;
|
||
}
|