Files
STM32F4-Base/IEC60870-Slave/test/iec104_software_upgrade_test.c
T
STF bdcc8b6500
CI / L0 静态门禁 (pre-commit) (push) Failing after 7m46s
CI / L0.5 主机侧单测 (MSVC) (push) Successful in 21s
添加遥控、参数装载、文件传输等业务
2026-11-16 22:19:17 -08:00

1009 lines
50 KiB
C
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
/* 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;
}