Files
STM32F4-Base/IEC60870-Slave/test/iec104_slave_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

1761 lines
88 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.
/* 共用子站发送接口回归:复用可控Net后端,验证真实104提交路径。
* 不另行链接TcpServer.c或Net后端。 */
/*
* 文件内导航(搜索方括号标记;Suite:Slave):
* 复用公共夹具的可控Net;先验证IEC60870公共应答分派,再验证104服务、站点注册表和44..49同步拒绝。
* [COMMON/BASE] 公共基础:依赖、编译选项与断言入口
* [COMMON/WIRE] 公共报文辅助:标准参数、请求向量与回显比较
* [COMMON/ASDU] 公共ASDU用例:可变视图、字段宽度与原地修改
* [COMMON/DISPATCH] 公共应答分派:记录型MasterConnection及接口用例
* [SLAVE/FIXTURE] 104专属辅助:服务创建、建连、通知消费与请求交付
* [SLAVE/REPLIES] 104应答用例:原事件、构造ASDU、WAIT及参数校验
* [SLAVE/IDENTITY] 104身份用例:延迟应答存储、请求状态及旧代次
* [SLAVE/LIFECYCLE] 104生命周期用例:FATAL、事件复制、重建、外部调度及离线上报
* [STATION/REGISTRY] 共用站点表用例:路由、引用、迭代锁、生命周期与快照
* [REJECT/FIXTURE] 同步拒绝专属辅助:请求输入、应答收集与传输收敛
* [REJECT/CASES] 同步拒绝44..49:回显、参数、拥塞、启停及故障
* [ENTRY/MAIN] 测试入口:公共层、104服务、站点及同步拒绝
* 公共辅助、业务专属辅助和用例按分区阅读;RUN/CASE标记用于细分执行组。
*/
/* ============================================================================
* [COMMON/BASE] 公共基础:依赖、编译选项与断言入口
* ============================================================================ */
#include "iec104_test_config.h"
#include "iec104_tcp_fixture.h"
#include "IEC104_Slave.h"
/* ============================================================================
* [COMMON/WIRE] 公共报文辅助:标准参数、请求向量与回显比较
* ============================================================================ */
static const IEC60870_AppLayerParameters_t slave_parameters = IEC104_APP_LAYER_PARAMETERS_DEFAULT;
/* Type100、TEST=1、OA=0x5A、CA=0x1234、IOA=0、QOI=20。 */
static const uint8_t interrogation[] = {100, 1, 0x86, 0x5A, 0x34, 0x12, 0, 0, 0, 20};
/**
* 功能:检查期望报文只改动COT首字节。
* 输入参数:actual——实际ASDU;original——输入副本;length——长度;cot——期望COT字节。
* 输出参数:无。
* 返回值:无。
* 说明:无,断言失败时终止测试。
* 检查不满足时立即报告失败,不继续本用例。
*/
static void check_reply(const uint8_t *actual, const uint8_t *original, size_t length, uint8_t cot)
{
size_t i;
for (i = 0; i < length; ++i) { CHECK(actual[i] == (i == 2U ? cot : original[i])); }
}
/* ============================================================================
* [COMMON/ASDU] 公共ASDU用例:可变视图、字段宽度与原地修改
* ============================================================================ */
/**
* 功能:验证12种字段宽度下的原文借用、原地修改和失败原子性。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:检查不满足时立即报告失败,不继续本用例。
*/
static void test_mutable_views(void)
{
int cot, ca, ioa;
for (cot = 1; cot <= 2; ++cot) {
for (ca = 1; ca <= 2; ++ca) {
for (ioa = 1; ioa <= 3; ++ioa) {
IEC60870_AppLayerParameters_t p = {1, 1, cot, 0, ca, ioa, 254};
uint8_t bytes[16] = {100, 1, 0xC6}, original[16];
uint16_t length = (uint16_t)(2 + cot + ca + ioa + 1), exported = 0;
const uint8_t *data = NULL;
IEC60870_Asdu_t object, snapshot;
IEC60870_InterrogationCommand_t command;
if (cot == 2) { bytes[3] = 0x5A; }
bytes[2 + cot] = 0x34;
if (ca == 2) { bytes[3 + cot] = 0x12; }
bytes[length - 1U] = 20;
memcpy(original, bytes, sizeof(bytes));
CHECK(IEC60870_Asdu_Create_From_Buffer(&object, &p, bytes, length) == IEC60870_ASDU_OK);
CHECK(object.buffer == bytes && object.capacity == length && object.is_from_buffer);
CHECK(memcmp(bytes, original, sizeof(bytes)) == 0);
CHECK(IEC60870_Asdu_Set_COT(&object, 7) == IEC60870_ASDU_OK);
check_reply(bytes, original, length, 0xC7);
CHECK(IEC60870_Asdu_Set_Negative(&object, 0) == IEC60870_ASDU_OK);
CHECK(IEC60870_Asdu_Get_Data(&object, &data, &exported) == IEC60870_ASDU_OK);
CHECK(data == bytes && exported == length);
check_reply(data, original, length, 0x87);
snapshot = object;
CHECK(IEC60870_Asdu_Set_COT(&object, -1) == IEC60870_ASDU_ERROR);
CHECK(IEC60870_Asdu_Set_COT(&object, 64) == IEC60870_ASDU_ERROR);
CHECK(IEC60870_Asdu_Set_Negative(&object, 2) == IEC60870_ASDU_ERROR);
CHECK(IEC60870_Asdu_Create_From_Buffer(&object, &p, bytes, length - 1U) == IEC60870_ASDU_ERROR);
CHECK(memcmp(&object, &snapshot, sizeof(object)) == 0);
CHECK(IEC60870_InterrogationCommand_Create(&command, 0, 20) == IEC60870_ASDU_OK);
CHECK(IEC60870_Asdu_Add_InformationObject(&object, &command.object) == IEC60870_ASDU_ERROR);
CHECK(memcmp(&object, &snapshot, sizeof(object)) == 0);
check_reply(bytes, original, length, 0x87);
CHECK(memcmp(bytes + length, original + length, sizeof(bytes) - length) == 0);
}
}
}
{
/* 未知类型及零对象可原文回显,但不能作为已校验业务对象执行。 */
IEC60870_AppLayerParameters_t p = {1, 1, 1, 0, 1, 1, 254};
uint8_t bytes[254] = {200, 0, 0x86, 1};
IEC60870_Asdu_t object, snapshot;
IEC60870_AsduInfo_t info;
const uint8_t *data = NULL;
uint16_t length = 0;
CHECK(IEC60870_Asdu_Create_From_Buffer(&object, &p, bytes, 4) == IEC60870_ASDU_OK);
CHECK(IEC60870_Asdu_Parse(&p, bytes, 4, &info) == IEC60870_ASDU_UNSUPPORTED);
CHECK(IEC60870_Asdu_Set_COT(&object, 44) == IEC60870_ASDU_OK);
CHECK(IEC60870_Asdu_Get_Data(&object, &data, &length) == IEC60870_ASDU_OK && length == 4);
CHECK(data == bytes && bytes[2] == 0xAC);
CHECK(IEC60870_Asdu_Create_From_Buffer(&object, &p, bytes, 254) == IEC60870_ASDU_OK);
CHECK(IEC60870_Asdu_Get_Data(&object, &data, &length) == IEC60870_ASDU_OK && length == 254);
snapshot = object;
CHECK(IEC60870_Asdu_Create_From_Buffer(&object, &p, bytes, 255) == IEC60870_ASDU_ERROR);
CHECK(IEC60870_Asdu_Create_From_Buffer(&object, NULL, bytes, 4) == IEC60870_ASDU_ERROR);
CHECK(IEC60870_Asdu_Create_From_Buffer(&object, &p, NULL, 4) == IEC60870_ASDU_ERROR);
CHECK(IEC60870_Asdu_Create_From_Buffer(NULL, &p, bytes, 4) == IEC60870_ASDU_ERROR);
CHECK(memcmp(&object, &snapshot, sizeof(object)) == 0);
CHECK(IEC60870_Asdu_Set_COT(NULL, 7) == IEC60870_ASDU_ERROR);
CHECK(IEC60870_Asdu_Set_Negative(NULL, 0) == IEC60870_ASDU_ERROR);
object.is_from_buffer = 2;
CHECK(IEC60870_Asdu_Set_COT(&object, 7) == IEC60870_ASDU_ERROR && bytes[2] == 0xAC);
}
}
/* ============================================================================
* [COMMON/DISPATCH] 公共应答分派:记录型MasterConnection及接口用例
* ============================================================================ */
typedef struct {
IEC60870_MasterConnection_t connection;
IEC60870_AppLayerParameters_t parameters;
IEC60870_Asdu_t *seen;
unsigned calls;
bool negative;
bool result;
} TestConnection;
/**
* 功能:测试接入只记录分派参数和返回值,用来确认共用层不替代协议实现。
* 输入参数:self——被测实例或连接;object——信息对象或 ASDU 存储。
* 输出参数:无。
* 返回值:返回连接探针预设结果,用于验证上层分派时保留后端的成功或失败。
* 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。
*/
static bool record_asdu(IEC60870_MasterConnection_t *self, IEC60870_Asdu_t *object)
{
TestConnection *test = (TestConnection *)self->object;
CHECK(self == &test->connection);
test->seen = object;
test->calls += 1U;
return test->result;
}
/**
* 功能:用不同计数增量标识ACT_CON回调,再记录原文。
* 输入参数:self——被测实例或连接;object——信息对象或 ASDU 存储;negative——是否设置否定确认标志。
* 输出参数:无。
* 返回值:返回连接探针预设结果,用于验证上层分派时保留后端的成功或失败。
* 说明:negative保留调用方的正/负确认选择。
*/
static bool record_con(IEC60870_MasterConnection_t *self, IEC60870_Asdu_t *object, bool negative)
{
TestConnection *test = (TestConnection *)self->object;
test->negative = negative;
test->calls += 10U;
return record_asdu(self, object);
}
/**
* 功能:用独立计数增量标识ACT_TERM回调,随后共用原文记录,检查主站连接抽象的正确分派。
* 输入参数:self——被测实例或连接;object——信息对象或 ASDU 存储。
* 输出参数:无。
* 返回值:返回连接探针预设结果,用于验证上层分派时保留后端的成功或失败。
* 说明:本辅助入口用于构造或核对上述测试场景,相关状态保存在当前测试夹具中。
*/
static bool record_term(IEC60870_MasterConnection_t *self, IEC60870_Asdu_t *object)
{
TestConnection *test = (TestConnection *)self->object;
test->calls += 100U;
return record_asdu(self, object);
}
/**
* 功能:返回测试连接自身的参数,供上层验证应用层参数访问没有串到其他连接。
* 输入参数:self——被测实例或连接。
* 输出参数:无。
* 返回值:当前测试连接持有的应用层参数指针。
* 说明:本辅助入口用于构造或核对上述测试场景,相关状态保存在当前测试夹具中。
*/
static const IEC60870_AppLayerParameters_t *record_parameters(IEC60870_MasterConnection_t *self)
{
return &((TestConnection *)self->object)->parameters;
}
/**
* 功能:验证共用接口的回调分派、布尔返回和非104参数传递。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:检查不满足时立即报告失败,不继续本用例。
*/
static void test_common_dispatch(void)
{
TestConnection test = {0};
IEC60870_MasterConnection_t empty = {0};
IEC60870_Asdu_t object = {0};
test.parameters = (IEC60870_AppLayerParameters_t){1, 1, 1, 0, 1, 2, 100};
test.connection.object = &test;
test.connection.send_asdu = record_asdu;
test.connection.send_act_con = record_con;
test.connection.send_act_term = record_term;
test.connection.get_application_layer_parameters = record_parameters;
test.result = true;
CHECK(IEC60870_MasterConnection_Send_ASDU(&test.connection, &object));
CHECK(IEC60870_MasterConnection_Send_ACT_CON(&test.connection, &object, true));
CHECK(test.negative);
CHECK(IEC60870_MasterConnection_Send_ACT_TERM(&test.connection, &object));
CHECK(test.calls == 113U && test.seen == &object);
CHECK(IEC60870_MasterConnection_Get_Application_Layer_Parameters(&test.connection) == &test.parameters);
test.result = false;
CHECK(!IEC60870_MasterConnection_Send_ACT_CON(&test.connection, &object, false));
CHECK(!test.negative && test.calls == 124U);
CHECK(!IEC60870_MasterConnection_Send_ASDU(NULL, &object));
CHECK(!IEC60870_MasterConnection_Send_ACT_CON(NULL, &object, false));
CHECK(!IEC60870_MasterConnection_Send_ACT_TERM(NULL, &object));
CHECK(!IEC60870_MasterConnection_Send_ASDU(&empty, &object));
CHECK(!IEC60870_MasterConnection_Send_ACT_CON(&empty, &object, false));
CHECK(!IEC60870_MasterConnection_Send_ACT_TERM(&empty, &object));
CHECK(IEC60870_MasterConnection_Get_Application_Layer_Parameters(NULL) == NULL);
CHECK(IEC60870_MasterConnection_Get_Application_Layer_Parameters(&empty) == NULL);
}
/* ============================================================================
* [SLAVE/FIXTURE] 104专属辅助:服务创建、建连、通知消费与请求交付
* ============================================================================ */
static IEC104_Slave_t *service;
/* 仅测试为了注入底层故障取得池中对象;正常业务测试只调用Slave公开接口。 */
/**
* 功能:查找测试当前唯一活动 Slave 所持有的真实 TCP 实例。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:测试只创建一个活动服务;找到其池内TCP实例后才能复用fake Net并检查内部背压状态。
*/
static void locate_test_server(void)
{
size_t i;
sut = NULL;
for (i = 0U; i < IEC104_TCP_SERVER_CAPACITY; ++i) {
if (server_pool[i].in_use != 0U) { sut = &server_pool[i].server; break; }
}
CHECK(sut != NULL);
}
/**
* 功能:仅推进一次Slave网络处理,不消费通知。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:调用方据测试目的选择显式读取或丢弃。
*/
static void service_poll(void) { CHECK(IEC104_Slave_Poll(service, 0, NULL) == IEC104_TCP_OK); }
/**
* 功能:消费当前 Slave 的全部通知并返回数量,不保留通知内容。
* 输入参数:无。
* 输出参数:无。
* 返回值:本次消费的 Slave 通知数量。
* 说明:仅用于无需保留内容的通知;需要校验身份/原文的场景须显式NextEvent,不能在这里提前消费。
*/
static unsigned service_drain(void)
{
IEC104_SlaveEvent_t event;
IEC104_TcpEventResult_t result;
unsigned count = 0;
while ((result = IEC104_Slave_NextEvent(service, &event)) == IEC104_TCP_EVENT_READY) { ++count; }
CHECK(result == IEC104_TCP_EVENT_EMPTY);
return count;
}
/**
* 功能:建立未连接的Slave并指定k,保留可控Net及内部server句柄用于制造窗口边界。
* 输入参数:window——发送窗口大小。
* 输出参数:无。
* 返回值:无。
* 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。
*/
static void service_open_with_window(uint16_t window)
{
IEC104_SlaveConfig_t config;
memset(&fake, 0, sizeof(fake));
fake.now = 1000;
service = IEC104_Slave_Create();
CHECK(service != NULL);
locate_test_server();
test_transport_config(&config);
config.protocol.link.k = window;
CHECK(IEC104_Slave_Init(service, &config, NULL) == IEC104_TCP_OK);
}
/**
* 功能:以发送记录容量作为默认k创建服务。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:尚未接受连接或执行STARTDT。
*/
static void service_open(void) { service_open_with_window(IEC104_TCP_RECORD_CAPACITY); }
/**
* 功能:分别消费CONNECTED和ACTIVATED,确保后续请求在通知读空、会话已激活的状态开始。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。
*/
static void service_connect(void)
{
fake.accept_pending = 1;
service_poll();
CHECK(service_drain() == 1);
push(start_act, sizeof(start_act));
service_poll();
CHECK(service_drain() == 1);
}
/**
* 功能:建立并激活一个干净会话。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:需要测试激活前状态时直接使用service_open。
*/
static void service_begin(void) { service_open(); service_connect(); }
/**
* 功能:Close产生的收尾通知仍属于服务寿命,读空后才Destroy,与业务模块的退出顺序保持一致。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。
*/
static void service_end(void)
{
CHECK(IEC104_Slave_Close(service, NULL) == IEC104_TCP_OK);
service_drain();
CHECK(IEC104_Slave_Destroy(service, NULL) == IEC104_TCP_OK);
service = NULL;
}
/**
* 功能:按给定N(S)发送一条总召请求并取出真实I_FRAME通知。
* 输入参数:event——业务或传输事件;ns——I 帧发送序号 N(S)。
* 输出参数:event——业务或传输事件。
* 返回值:无。
* 说明:返回事件含自引用,不得按结构赋值长期保存。
*/
static void receive_request(IEC104_SlaveEvent_t *event, uint16_t ns)
{
uint8_t input[16];
CHECK(IEC104_Build_Iframe(input, ns, 0, interrogation, sizeof(interrogation)) == 16);
push(input, sizeof(input));
service_poll();
CHECK(IEC104_Slave_NextEvent(service, event) == IEC104_TCP_EVENT_READY);
CHECK(event->transport.type == IEC104_TCP_EVENT_I_FRAME);
CHECK(event->asdu_result == IEC60870_ASDU_OK);
}
/* ============================================================================
* [SLAVE/REPLIES] 104应答用例:原事件、构造ASDU、WAIT及参数校验
* ============================================================================ */
/**
* 功能:验证以下场景与约束:无需手动Init连接或解析ASDU,直接确认。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:检查完整报文及出队失败的输出保留。
*/
static void test_event_replies(void)
{
IEC104_SlaveEvent_t event, snapshot;
const IEC60870_AppLayerParameters_t *parameters;
size_t offset;
unsigned i;
static const uint8_t expected_cot[] = {0x87, 0xC7, 0x8A};
service_begin();
receive_request(&event, 0);
CHECK(event.asdu.buffer == event.transport.data.i_frame.apdu + IEC104_APCI_LEN);
parameters = IEC60870_MasterConnection_Get_Application_Layer_Parameters(&event.connection);
CHECK(parameters != NULL && parameters->sizeOfCOT == 2 && parameters->sizeOfCA == 2 &&
parameters->sizeOfIOA == 3 && parameters->maxSizeOfASDU == 249);
CHECK(parameters == IEC104_Slave_Get_Application_Layer_Parameters(service));
offset = fake.sent_bytes;
CHECK(IEC60870_MasterConnection_Send_ACT_CON(&event.connection, &event.asdu, false));
CHECK(IEC60870_MasterConnection_Send_ACT_CON(&event.connection, &event.asdu, true));
CHECK(IEC60870_MasterConnection_Send_ACT_TERM(&event.connection, &event.asdu));
CHECK(IEC104_Slave_Get_Last_Submit_Result(&event.connection) == IEC104_TCP_SUBMIT_OK);
CHECK(fake.sent_bytes == offset + 48U);
for (i = 0; i < 3; ++i) {
const uint8_t *frame = fake.output + offset + i * 16U;
CHECK(frame[0] == 0x68 && frame[1] == 14 && frame[2] == 2U * i && frame[3] == 0);
CHECK(frame[4] == 2 && frame[5] == 0);
check_reply(frame + 6, interrogation, 10, expected_cot[i]);
}
check_reply(event.asdu.buffer, interrogation, 10, 0x8A);
memcpy(&snapshot, &event, sizeof(snapshot));
CHECK(IEC104_Slave_NextEvent(service, &event) == IEC104_TCP_EVENT_EMPTY);
CHECK(memcmp(&snapshot, &event, sizeof(event)) == 0);
CHECK(IEC104_Slave_NextEvent(NULL, &event) == IEC104_TCP_EVENT_ERROR);
CHECK(memcmp(&snapshot, &event, sizeof(event)) == 0);
CHECK(IEC104_Slave_NextEvent(service, NULL) == IEC104_TCP_EVENT_ERROR);
service_end();
}
/**
* 功能:验证以下场景与约束:同一自动绑定的连接也可提交业务另行构造的ASDU。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。
*/
static void test_constructed_asdu(void)
{
uint8_t buffer[249];
IEC104_SlaveEvent_t event;
IEC60870_Asdu_t object;
IEC60870_AsduHeader_t header = {3, 0, 0, 0, 1};
IEC60870_SinglePointInformation_t point;
const uint8_t *data = NULL;
uint16_t length = 0;
service_begin();
receive_request(&event, 0);
CHECK(IEC60870_Asdu_Create(&object, &slave_parameters, buffer, sizeof(buffer), &header, 0) == IEC60870_ASDU_OK);
CHECK(IEC60870_Asdu_Set_COT(&object, 20) == IEC60870_ASDU_OK);
CHECK(!IEC60870_MasterConnection_Send_ASDU(&event.connection, &object));
CHECK(IEC104_Slave_Get_Last_Submit_Result(&event.connection) == IEC104_TCP_SUBMIT_ERROR);
CHECK(IEC60870_SinglePointInformation_Create(&point, 1, 1, 0) == IEC60870_ASDU_OK);
CHECK(IEC60870_Asdu_Add_InformationObject(&object, &point.object) == IEC60870_ASDU_OK);
CHECK(IEC60870_Asdu_Get_Data(&object, &data, &length) == IEC60870_ASDU_OK && length == 10);
CHECK(IEC60870_MasterConnection_Send_ASDU(&event.connection, &object));
CHECK(fake.sent_bytes == 22);
check_reply(fake.output + 12, asdu, 10, 20);
CHECK(memcmp(fake.output + 12, data, length) == 0);
service_end();
}
/**
* 功能:验证以下场景与约束:HIGH满后的WAIT不接手,复制事件保留已修改字段后可在容量恢复时重试。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。
*/
static void test_wait_and_retry(void)
{
IEC104_SlaveEvent_t event, pending;
IEC104_TcpServerStatus_t before, after;
unsigned accepted;
service_begin();
receive_request(&event, 0);
fake.send_blocked = 1;
for (accepted = 0; accepted < 200; ++accepted) {
if (!IEC60870_MasterConnection_Send_ASDU(&event.connection, &event.asdu)) { break; }
}
CHECK(accepted > 0 && accepted < 200);
CHECK(IEC104_Slave_Get_Last_Submit_Result(&event.connection) == IEC104_TCP_SUBMIT_WAIT);
CHECK(IEC104_Slave_Get_Status(service, &before, NULL) == IEC104_TCP_OK);
CHECK(!IEC60870_MasterConnection_Send_ACT_CON(&event.connection, &event.asdu, true));
CHECK(IEC104_Slave_Get_Last_Submit_Result(&event.connection) == IEC104_TCP_SUBMIT_WAIT);
check_reply(event.asdu.buffer, interrogation, 10, 0xC7);
CHECK(IEC104_Slave_Get_Status(service, &after, NULL) == IEC104_TCP_OK);
CHECK(before.high_queue.pending_asdu_count == after.high_queue.pending_asdu_count);
CHECK(IEC104_Slave_Copy_Event(&pending, &event));
memset(&event, 0, sizeof(event));
fake.send_blocked = 0;
fake.now += 100;
service_poll();
CHECK(IEC60870_MasterConnection_Send_ACT_CON(&pending.connection, &pending.asdu, true));
CHECK(IEC104_Slave_Get_Last_Submit_Result(&pending.connection) == IEC104_TCP_SUBMIT_OK);
service_end();
}
/**
* 功能:验证以下场景与约束:保留101布局/254长度/NULL拒绝,以及复制自引用接口后的明确失败。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。
*/
static void test_invalid_inputs(void)
{
IEC104_SlaveEvent_t event, snapshot, destination, before;
IEC60870_AppLayerParameters_t p = {1, 1, 1, 0, 1, 1, 254};
IEC60870_Asdu_t object;
uint8_t bytes[254] = {200, 0, 0x86, 1};
size_t sent;
service_begin();
receive_request(&event, 0);
snapshot = event; /* 故意模拟错误的按值复制。 */
CHECK(IEC104_Slave_Get_Last_Submit_Result(NULL) == IEC104_TCP_SUBMIT_ERROR);
sent = fake.sent_bytes;
CHECK(IEC60870_Asdu_Create_From_Buffer(&object, &p, bytes, 4) == IEC60870_ASDU_OK);
CHECK(!IEC60870_MasterConnection_Send_ACT_CON(&event.connection, &object, false));
CHECK(bytes[2] == 0x87);
CHECK(IEC104_Slave_Get_Last_Submit_Result(&event.connection) == IEC104_TCP_SUBMIT_ERROR);
CHECK(IEC104_Slave_Enqueue_Event(service, &object) == IEC104_TCP_SUBMIT_ERROR);
p = slave_parameters;
p.maxSizeOfASDU = 254;
CHECK(IEC60870_Asdu_Create_From_Buffer(&object, &p, bytes, 254) == IEC60870_ASDU_OK);
CHECK(!IEC60870_MasterConnection_Send_ACT_TERM(&event.connection, &object));
CHECK(bytes[2] == 0x8A);
CHECK(!IEC60870_MasterConnection_Send_ASDU(&event.connection, NULL));
CHECK(!IEC60870_MasterConnection_Send_ACT_CON(&event.connection, NULL, false));
CHECK(!IEC60870_MasterConnection_Send_ACT_TERM(&event.connection, NULL));
CHECK(IEC104_Slave_Enqueue_Event(service, NULL) == IEC104_TCP_SUBMIT_ERROR);
CHECK(fake.sent_bytes == sent);
CHECK(!IEC60870_MasterConnection_Send_ACT_TERM(&snapshot.connection, &object));
CHECK(IEC60870_MasterConnection_Get_Application_Layer_Parameters(&snapshot.connection) == NULL);
CHECK(IEC104_Slave_Get_Last_Submit_Result(&snapshot.connection) == IEC104_TCP_SUBMIT_ERROR);
memset(&destination, 0x5A, sizeof(destination));
memcpy(&before, &destination, sizeof(before));
CHECK(!IEC104_Slave_Copy_Event(&destination, &snapshot));
CHECK(!IEC104_Slave_Copy_Event(&destination, NULL));
CHECK(!IEC104_Slave_Copy_Event(NULL, &event));
CHECK(memcmp(&destination, &before, sizeof(destination)) == 0);
service_end();
}
/* ============================================================================
* [SLAVE/IDENTITY] 104身份用例:延迟应答存储、请求状态及旧代次
* ============================================================================ */
/**
* 功能:验证以下场景与约束:原事件可以立即复用。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:普通/带凭证提交只依赖独立身份及本次ASDU,接手后不借用输入。
*/
static void test_identity_response_storage(void)
{
IEC104_SlaveEvent_t event;
IEC104_SlaveEventIdentity_t identity;
IEC60870_Asdu_t object;
uint8_t bytes[sizeof(interrogation)];
size_t sent;
service_begin(); receive_request(&event, 0);
CHECK(IEC104_Slave_Get_Event_Identity(service, &event, &identity));
memcpy(bytes, interrogation, sizeof(bytes));
CHECK(IEC60870_Asdu_Create_From_Buffer(&object, &slave_parameters, bytes, sizeof(bytes)) == IEC60870_ASDU_OK);
memset(&event, 0xCC, sizeof(event));
CHECK(IEC60870_Asdu_Set_COT(&object, 7) == IEC60870_ASDU_OK);
sent = fake.sent_bytes;
CHECK(IEC104_Slave_Send_Response(service, &identity, &object) == IEC104_TCP_SUBMIT_OK);
CHECK(fake.sent_bytes == sent + 16U);
check_reply(fake.output + sent + 6U, interrogation, 10, 0x87);
CHECK(IEC60870_Asdu_Set_COT(&object, 10) == IEC60870_ASDU_OK);
fake.send_blocked = 1;
sent = fake.sent_bytes;
CHECK(IEC104_Slave_Send_Response_Tracked(service, &identity, &object, NULL) == IEC104_TCP_SUBMIT_OK);
CHECK(fake.sent_bytes == sent);
memset(bytes, 0xCC, sizeof(bytes));
fake.send_blocked = 0; service_poll();
CHECK(fake.sent_bytes == sent + 16U);
check_reply(fake.output + sent + 6U, interrogation, 10, 0x8A);
CHECK(IEC104_Slave_Close_Connection_By_Identity(service, &identity, NULL) == IEC104_TCP_OK);
CHECK(IEC104_Slave_Close_Connection_By_Identity(service, &identity, NULL) == IEC104_TCP_NOT_CONNECTED);
service_end();
}
/**
* 功能:验证以下场景与约束:HIGH满时WAIT且保留输出凭证。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:旧NORMAL未发送时,仍可直接交接应答,不建立跨队列屏障。
*/
static void test_identity_response_wait(void)
{
IEC104_SlaveEvent_t event;
IEC104_SlaveEventIdentity_t identity;
IEC104_TcpServerStatus_t before, after;
unsigned accepted;
uint64_t ticket = UINT64_MAX;
service_begin(); receive_request(&event, 0);
CHECK(IEC104_Slave_Get_Event_Identity(service, &event, &identity));
fake.send_blocked = 1;
for (accepted = 0; accepted < 200; ++accepted) {
IEC104_TcpSubmitResult_t result = IEC104_Slave_Send_Response(service, &identity, &event.asdu);
if (result == IEC104_TCP_SUBMIT_WAIT) { break; }
CHECK(result == IEC104_TCP_SUBMIT_OK);
}
/* 第一条停在当前发送帧,后续才占HIGH;每条另有2字节队列头,不能只按ASDU长度估容量。 */
CHECK(accepted == 1U + IEC104_TCP_HIGH_CAPACITY / (IEC104_ASDU_HIGH_ENTRY_HEADER_LEN + sizeof(interrogation)));
CHECK(IEC104_Slave_Get_Status(service, &before, NULL) == IEC104_TCP_OK);
CHECK(IEC104_Slave_Send_Response_Tracked(service, &identity, &event.asdu, &ticket) == IEC104_TCP_SUBMIT_WAIT);
CHECK(ticket == UINT64_MAX);
CHECK(IEC104_Slave_Get_Status(service, &after, NULL) == IEC104_TCP_OK);
CHECK(before.high_queue.used_bytes == after.high_queue.used_bytes &&
before.connection.pending_send_records == after.connection.pending_send_records);
fake.send_blocked = 0; service_poll(); service_drain();
CHECK(IEC104_Slave_Send_Response(service, &identity, &event.asdu) == IEC104_TCP_SUBMIT_OK);
service_end();
service_begin(); receive_request(&event, 0);
CHECK(IEC104_Slave_Get_Event_Identity(service, &event, &identity));
CHECK(IEC104_Slave_Enqueue_Event(service, &event.asdu) == IEC104_TCP_SUBMIT_OK);
CHECK(IEC104_Slave_Get_Status(service, &before, NULL) == IEC104_TCP_OK);
CHECK(IEC104_Slave_Send_Response_Tracked(service, &identity, &event.asdu, &ticket) == IEC104_TCP_SUBMIT_OK);
CHECK(ticket == 0U);
CHECK(IEC104_Slave_Get_Response_State(service, ticket) == IEC104_RESPONSE_HANDED);
CHECK(IEC104_Slave_Get_Status(service, &after, NULL) == IEC104_TCP_OK);
CHECK(after.high_queue.used_bytes == before.high_queue.used_bytes &&
after.normal_queue.used_bytes == before.normal_queue.used_bytes &&
after.normal_queue.pending_asdu_count == before.normal_queue.pending_asdu_count);
service_poll(); service_drain();
CHECK(IEC104_Slave_Get_Response_State(service, ticket) == IEC104_RESPONSE_HANDED);
CHECK(IEC104_Slave_Send_Response_Tracked(service, &identity, &event.asdu, &ticket) == IEC104_TCP_SUBMIT_OK);
CHECK(ticket == 0U);
service_end();
}
/**
* 功能:验证以下场景与约束:紧凑身份入口保留原实例/代次校验、参数拒绝和FATAL语义,不因省去事件而放宽准入。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。
*/
static void test_identity_response_validation(void)
{
IEC104_SlaveEvent_t event;
IEC104_SlaveEventIdentity_t identity, invalid;
IEC60870_Asdu_t object;
IEC60870_AppLayerParameters_t parameters = {1, 1, 1, 0, 1, 1, 249};
uint8_t bytes[] = {200, 0, 3, 1};
size_t sent;
service_begin(); receive_request(&event, 0);
CHECK(IEC104_Slave_Get_Event_Identity(service, &event, &identity));
sent = fake.sent_bytes;
CHECK(IEC104_Slave_Send_Response(NULL, &identity, &event.asdu) == IEC104_TCP_SUBMIT_ERROR);
CHECK(IEC104_Slave_Send_Response(service, NULL, &event.asdu) == IEC104_TCP_SUBMIT_ERROR);
CHECK(IEC104_Slave_Send_Response_Tracked(service, &identity, NULL, NULL) == IEC104_TCP_SUBMIT_ERROR);
invalid = identity; invalid.slave = NULL;
CHECK(IEC104_Slave_Send_Response(service, &invalid, &event.asdu) == IEC104_TCP_SUBMIT_ERROR);
invalid = identity; ++invalid.instance_id;
CHECK(IEC104_Slave_Send_Response_Tracked(service, &invalid, &event.asdu, NULL) == IEC104_TCP_SUBMIT_ERROR);
CHECK(IEC104_Slave_Close_Connection_By_Identity(service, &invalid, NULL) == IEC104_TCP_INVALID_ARGUMENT);
invalid = identity; invalid.generation = 0;
CHECK(IEC104_Slave_Send_Response(service, &invalid, &event.asdu) == IEC104_TCP_SUBMIT_ERROR);
CHECK(IEC104_Slave_Close_Connection_By_Identity(service, &invalid, NULL) == IEC104_TCP_INVALID_ARGUMENT);
CHECK(IEC104_Slave_Close_Connection_By_Identity(NULL, &identity, NULL) == IEC104_TCP_INVALID_HANDLE);
CHECK(IEC104_Slave_Close_Connection_By_Identity(service, NULL, NULL) == IEC104_TCP_INVALID_ARGUMENT);
CHECK(IEC60870_Asdu_Create_From_Buffer(&object, &parameters, bytes, sizeof(bytes)) == IEC60870_ASDU_OK);
CHECK(IEC104_Slave_Send_Response(service, &identity, &object) == IEC104_TCP_SUBMIT_ERROR);
CHECK(IEC104_Slave_Send_Response_Tracked(service, &identity, &object, NULL) == IEC104_TCP_SUBMIT_ERROR);
CHECK(fake.sent_bytes == sent);
sut->queue_initialized = 0;
CHECK(IEC104_Slave_Send_Response_Tracked(service, &identity, &event.asdu, NULL) == IEC104_TCP_SUBMIT_FATAL);
sut->queue_initialized = 1;
push(stop_act, sizeof(stop_act)); service_poll(); service_drain();
CHECK(IEC104_Slave_Send_Response(service, &identity, &event.asdu) == IEC104_TCP_SUBMIT_ERROR);
CHECK(IEC104_Slave_Send_Response_Tracked(service, &identity, &event.asdu, NULL) == IEC104_TCP_SUBMIT_ERROR);
service_end();
}
/**
* 功能:验证以下场景与约束:身份输出独立于事件存储。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:非法来源、自引用和元数据不得污染输出或复制目标。
*/
static void test_event_identity(void)
{
IEC104_SlaveEvent_t event, copied, moved;
IEC104_SlaveEventIdentity_t identity, before, copy_identity;
size_t sent;
service_begin();
receive_request(&event, 0);
sent = fake.sent_bytes;
CHECK(IEC104_Slave_Get_Event_Identity(service, &event, &identity));
CHECK(identity.slave == service && identity.instance_id != 0U &&
identity.generation == event.transport.generation);
before = identity;
CHECK(!IEC104_Slave_Get_Event_Identity(NULL, &event, &identity));
CHECK(!IEC104_Slave_Get_Event_Identity(service, NULL, &identity));
CHECK(!IEC104_Slave_Get_Event_Identity(service, &event, NULL));
moved = event; /* 未修复自引用的按值副本必须拒绝。 */
CHECK(!IEC104_Slave_Get_Event_Identity(service, &moved, &identity));
CHECK(memcmp(&identity, &before, sizeof(identity)) == 0);
CHECK(IEC104_Slave_Copy_Event(&copied, &event));
++copied.transport.generation; /* 两份连接代次不一致,不能接受或继续传播。 */
CHECK(!IEC104_Slave_Get_Event_Identity(service, &copied, &identity));
CHECK(!IEC104_Slave_Copy_Event(&moved, &copied));
CHECK(memcmp(&identity, &before, sizeof(identity)) == 0);
CHECK(IEC104_Slave_Copy_Event(&copied, &event));
memset(&event, 0, sizeof(event));
CHECK(IEC104_Slave_Get_Event_Identity(service, &copied, &copy_identity));
CHECK(copy_identity.slave == identity.slave && copy_identity.instance_id == identity.instance_id &&
copy_identity.generation == identity.generation);
CHECK(IEC104_Slave_Check_Request(service, &identity) == IEC104_SLAVE_REQUEST_READY);
#if IEC104_TCP_SERVER_CAPACITY > 1
{
IEC104_Slave_t *other = IEC104_Slave_Create();
CHECK(other != NULL);
CHECK(!IEC104_Slave_Get_Event_Identity(other, &copied, &identity));
CHECK(memcmp(&identity, &before, sizeof(identity)) == 0);
CHECK(IEC104_Slave_Send_Response(other, &identity, &copied.asdu) == IEC104_TCP_SUBMIT_ERROR);
CHECK(IEC104_Slave_Send_Response_Tracked(other, &identity, &copied.asdu, NULL) == IEC104_TCP_SUBMIT_ERROR);
CHECK(IEC104_Slave_Close_Connection_By_Identity(other, &identity, NULL) == IEC104_TCP_INVALID_ARGUMENT);
copy_identity.slave = other; /* 即使局部编号相同,其他服务身份也不能用于当前会话。 */
CHECK(IEC104_Slave_Check_Request(service, &copy_identity) == IEC104_SLAVE_REQUEST_STALE);
CHECK(IEC104_Slave_Destroy(other, NULL) == IEC104_TCP_OK);
}
#endif
CHECK(fake.sent_bytes == sent);
service_end();
}
/**
* 功能:验证以下场景与约束:通知FIFO优先于当前传输状态:不能跨过尚未消费的STOP/START继续旧业务。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。
*/
static void test_request_state(void)
{
IEC104_SlaveEvent_t event;
IEC104_SlaveEventIdentity_t identity = {0};
size_t sent;
service_open();
CHECK(IEC104_Slave_Check_Request(NULL, &identity) == IEC104_SLAVE_REQUEST_ERROR);
CHECK(IEC104_Slave_Check_Request(service, NULL) == IEC104_SLAVE_REQUEST_ERROR);
CHECK(IEC104_Slave_Check_Request(service, &identity) == IEC104_SLAVE_REQUEST_STALE);
fake.accept_pending = 1;
service_poll();
CHECK(IEC104_Slave_Check_Request(service, &identity) == IEC104_SLAVE_REQUEST_WAIT_EVENTS);
CHECK(IEC104_Slave_NextEvent(service, &event) == IEC104_TCP_EVENT_READY);
CHECK(event.transport.type == IEC104_TCP_EVENT_CONNECTED);
CHECK(IEC104_Slave_Get_Event_Identity(service, &event, &identity));
CHECK(IEC104_Slave_Check_Request(service, &identity) == IEC104_SLAVE_REQUEST_STALE);
push(start_act, sizeof(start_act)); service_poll();
CHECK(IEC104_Slave_Check_Request(service, &identity) == IEC104_SLAVE_REQUEST_WAIT_EVENTS);
CHECK(service_drain() == 1);
CHECK(IEC104_Slave_Check_Request(service, &identity) == IEC104_SLAVE_REQUEST_READY);
push(stop_act, sizeof(stop_act)); service_poll();
CHECK(IEC104_Slave_Check_Request(service, &identity) == IEC104_SLAVE_REQUEST_WAIT_EVENTS);
CHECK(service_drain() == 1);
CHECK(IEC104_Slave_Check_Request(service, &identity) == IEC104_SLAVE_REQUEST_STALE);
push(start_act, sizeof(start_act)); service_poll();
CHECK(service_drain() == 1);
push(stop_act, sizeof(stop_act)); service_poll();
push(start_act, sizeof(start_act)); service_poll();
CHECK(IEC104_Slave_Check_Request(service, &identity) == IEC104_SLAVE_REQUEST_WAIT_EVENTS);
CHECK(IEC104_Slave_NextEvent(service, &event) == IEC104_TCP_EVENT_READY);
CHECK(event.transport.type == IEC104_TCP_EVENT_DEACTIVATED);
CHECK(IEC104_Slave_Check_Request(service, &identity) == IEC104_SLAVE_REQUEST_WAIT_EVENTS);
CHECK(IEC104_Slave_NextEvent(service, &event) == IEC104_TCP_EVENT_READY);
CHECK(event.transport.type == IEC104_TCP_EVENT_ACTIVATED);
sent = fake.sent_bytes;
CHECK(IEC104_Slave_Check_Request(service, &identity) == IEC104_SLAVE_REQUEST_READY);
CHECK(IEC104_Slave_Check_Request(service, &identity) == IEC104_SLAVE_REQUEST_READY);
CHECK(fake.sent_bytes == sent && service_drain() == 0U);
CHECK(IEC104_Slave_Close_Connection(service, &event, NULL) == IEC104_TCP_OK);
CHECK(IEC104_Slave_Check_Request(service, &identity) == IEC104_SLAVE_REQUEST_WAIT_EVENTS);
CHECK(service_drain() == 1);
CHECK(IEC104_Slave_Check_Request(service, &identity) == IEC104_SLAVE_REQUEST_STALE);
service_end();
}
/**
* 功能:验证以下场景与约束:旧事件的发送和关闭操作均不能作用于新连接,业务无须提取或回传generation。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。
*/
static void test_stale_generation(void)
{
IEC104_SlaveEvent_t old_event, current;
IEC104_SlaveEventIdentity_t old_identity, current_identity;
size_t sent;
service_begin();
receive_request(&old_event, 0);
CHECK(IEC104_Slave_Get_Event_Identity(service, &old_event, &old_identity));
CHECK(IEC104_Slave_Close_Connection(service, &old_event, NULL) == IEC104_TCP_OK);
service_drain();
service_connect();
receive_request(&current, 0);
CHECK(old_event.transport.generation != current.transport.generation);
CHECK(IEC104_Slave_Get_Event_Identity(service, &old_event, &current_identity));
CHECK(current_identity.generation == old_identity.generation); /* 历史事件仍可识别,但不能继续业务。 */
CHECK(IEC104_Slave_Check_Request(service, &old_identity) == IEC104_SLAVE_REQUEST_STALE);
CHECK(IEC104_Slave_Get_Event_Identity(service, &current, &current_identity));
CHECK(IEC104_Slave_Check_Request(service, &current_identity) == IEC104_SLAVE_REQUEST_READY);
sent = fake.sent_bytes;
CHECK(IEC104_Slave_Close_Connection(service, &old_event, NULL) == IEC104_TCP_STALE_GENERATION);
CHECK(IEC104_Slave_Close_Connection_By_Identity(service, &old_identity, NULL) == IEC104_TCP_STALE_GENERATION);
CHECK(IEC104_Slave_Send_Response(service, &old_identity, &current.asdu) == IEC104_TCP_SUBMIT_ERROR);
CHECK(IEC104_Slave_Send_Response_Tracked(service, &old_identity, &current.asdu, NULL) == IEC104_TCP_SUBMIT_ERROR);
CHECK(!IEC60870_MasterConnection_Send_ACT_CON(&old_event.connection, &old_event.asdu, false));
CHECK(IEC104_Slave_Get_Last_Submit_Result(&old_event.connection) == IEC104_TCP_SUBMIT_ERROR);
CHECK(fake.sent_bytes == sent && old_event.asdu.buffer[2] == 0x87);
CHECK(IEC60870_MasterConnection_Send_ACT_CON(&current.connection, &current.asdu, false));
CHECK(fake.sent_bytes == sent + 16U);
service_end();
}
/* ============================================================================
* [SLAVE/LIFECYCLE] 104生命周期用例:FATAL、事件复制、重建、外部调度及离线上报
* ============================================================================ */
/**
* 功能:验证致命传输错误经 Slave 公开接口传播,连接生命周期与故障状态保持一致。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。
*/
static void test_fatal_result(void)
{
IEC104_SlaveEvent_t event;
service_begin();
receive_request(&event, 0);
/* 故障注入只在测试中访问底层,不为业务增加内部句柄访问接口。 */
sut->queue_initialized = 0;
CHECK(!IEC60870_MasterConnection_Send_ACT_CON(&event.connection, &event.asdu, false));
CHECK(IEC104_Slave_Get_Last_Submit_Result(&event.connection) == IEC104_TCP_SUBMIT_FATAL);
CHECK(event.asdu.buffer[2] == 0x87);
sut->queue_initialized = 1;
service_end();
}
/**
* 功能:验证以下场景与约束:源事件被后续请求覆盖后,任务副本仍持有自己的原文与应答接口。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。
*/
static void test_deferred_event_copy(void)
{
IEC104_SlaveEvent_t source, pending;
uint64_t original_serial;
service_begin();
receive_request(&source, 0);
original_serial = source.transport.data.i_frame.receive_serial;
CHECK(IEC60870_Asdu_Set_COT(&source.asdu, 7) == IEC60870_ASDU_OK);
CHECK(IEC104_Slave_Copy_Event(&pending, &source));
CHECK(IEC104_Slave_Copy_Event(&pending, &pending));
CHECK(pending.asdu.buffer != source.asdu.buffer);
CHECK(pending.connection.object == &pending);
receive_request(&source, 1);
CHECK(source.transport.data.i_frame.receive_serial != original_serial);
CHECK(pending.transport.data.i_frame.receive_serial == original_serial);
CHECK(source.asdu.buffer[2] == 0x86 && pending.asdu.buffer[2] == 0x87);
CHECK(IEC60870_MasterConnection_Send_ACT_TERM(&pending.connection, &pending.asdu));
CHECK(source.asdu.buffer[2] == 0x86 && pending.asdu.buffer[2] == 0x8A);
service_end();
}
/**
* 功能:验证以下场景与约束:服务重启、销毁和池槽复用后,仍存活的任务副本都不得向新实例发送。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。
*/
static void test_service_reuse(void)
{
IEC104_SlaveEvent_t old_event, current;
IEC104_SlaveEventIdentity_t old_identity, identity;
IEC104_SlaveConfig_t config;
IEC104_Slave_t *old_service;
size_t sent;
service_begin();
receive_request(&old_event, 0);
CHECK(IEC104_Slave_Get_Event_Identity(service, &old_event, &old_identity));
CHECK(IEC104_Slave_Close(service, NULL) == IEC104_TCP_OK);
CHECK(IEC104_Slave_Init(service, NULL, NULL) == IEC104_TCP_INVALID_ARGUMENT);
service_drain();
test_transport_config(&config);
CHECK(IEC104_Slave_Init(service, &config, NULL) == IEC104_TCP_OK);
service_connect();
receive_request(&current, 0);
CHECK(IEC104_Slave_Check_Request(service, &old_identity) == IEC104_SLAVE_REQUEST_STALE);
sent = fake.sent_bytes;
CHECK(!IEC60870_MasterConnection_Send_ACT_CON(&old_event.connection, &old_event.asdu, false));
CHECK(fake.sent_bytes == sent);
CHECK(IEC60870_MasterConnection_Send_ACT_CON(&current.connection, &current.asdu, false));
old_service = service;
service_end();
CHECK(!IEC60870_MasterConnection_Send_ACT_TERM(&old_event.connection, &old_event.asdu));
service_begin();
CHECK(service == old_service); /* 默认先复用门面第一个槽。 */
receive_request(&current, 0);
CHECK(IEC104_Slave_Get_Event_Identity(service, &current, &identity));
CHECK(old_identity.instance_id != identity.instance_id);
CHECK(!IEC104_Slave_Get_Event_Identity(service, &old_event, &identity));
CHECK(IEC104_Slave_Check_Request(service, &old_identity) == IEC104_SLAVE_REQUEST_STALE);
sent = fake.sent_bytes;
CHECK(!IEC60870_MasterConnection_Send_ACT_CON(&old_event.connection, &old_event.asdu, false));
CHECK(IEC104_Slave_Close_Connection(service, &old_event, NULL) == IEC104_TCP_INVALID_ARGUMENT);
CHECK(IEC104_Slave_Close_Connection_By_Identity(service, &old_identity, NULL) == IEC104_TCP_INVALID_ARGUMENT);
CHECK(IEC104_Slave_Send_Response(service, &old_identity, &current.asdu) == IEC104_TCP_SUBMIT_ERROR);
CHECK(IEC104_Slave_Send_Response_Tracked(service, &old_identity, &current.asdu, NULL) == IEC104_TCP_SUBMIT_ERROR);
CHECK(fake.sent_bytes == sent);
CHECK(IEC60870_MasterConnection_Send_ACT_CON(&current.connection, &current.asdu, false));
service_end();
}
/**
* 功能:验证以下场景与约束:两层池共享容量。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:创建失败不泄漏,Close后的收尾通知不能被Destroy悄悄丢弃。
*/
static void test_lifecycle(void)
{
IEC104_Slave_t *slots[IEC104_TCP_SERVER_CAPACITY];
IEC104_TcpServer_t *tcp_slots[IEC104_TCP_SERVER_CAPACITY];
IEC104_SlaveEvent_t event;
IEC104_TcpError_t error;
IEC104_SlaveConfig_t config;
IEC104_TcpServerStatus_t status;
size_t i;
for (i = 0; i < IEC104_TCP_SERVER_CAPACITY; ++i) {
slots[i] = IEC104_Slave_Create();
CHECK(slots[i] != NULL);
}
CHECK(IEC104_Slave_Create() == NULL && IEC104_TcpServer_Create() == NULL);
for (i = 0; i < IEC104_TCP_SERVER_CAPACITY; ++i) {
CHECK(IEC104_Slave_Destroy(slots[i], NULL) == IEC104_TCP_OK);
}
for (i = 0; i < IEC104_TCP_SERVER_CAPACITY; ++i) {
tcp_slots[i] = IEC104_TcpServer_Create();
CHECK(tcp_slots[i] != NULL);
}
CHECK(IEC104_Slave_Create() == NULL);
for (i = 0; i < IEC104_TCP_SERVER_CAPACITY; ++i) {
CHECK(IEC104_TcpServer_Destroy(tcp_slots[i], NULL) == IEC104_TCP_OK);
}
service = IEC104_Slave_Create();
CHECK(service != NULL);
CHECK(IEC104_Slave_Get_Status(service, &status, NULL) == IEC104_TCP_OK && !status.listening);
test_transport_config(&config);
config.protocol.link.k = 0;
CHECK(IEC104_Slave_Init(service, &config, &error) == IEC104_TCP_INVALID_CONFIG);
CHECK(error.result == IEC104_TCP_INVALID_CONFIG && error.stage == IEC104_TCP_STAGE_VALIDATE);
CHECK(IEC104_Slave_Destroy(service, NULL) == IEC104_TCP_OK);
CHECK(IEC104_Slave_Destroy(service, &error) == IEC104_TCP_INVALID_HANDLE);
CHECK(error.result == IEC104_TCP_INVALID_HANDLE);
service_begin();
CHECK(IEC104_Slave_Destroy(service, NULL) == IEC104_TCP_INVALID_STATE);
CHECK(IEC104_Slave_Close(service, NULL) == IEC104_TCP_OK);
CHECK(IEC104_Slave_Destroy(service, NULL) == IEC104_TCP_EVENTS_PENDING);
CHECK(IEC104_Slave_NextEvent(service, &event) == IEC104_TCP_EVENT_READY);
CHECK(event.transport.type == IEC104_TCP_EVENT_DISCONNECTED);
CHECK(event.asdu_result == IEC60870_ASDU_UNSUPPORTED && event.connection.send_asdu == NULL);
CHECK(IEC104_Slave_Destroy(service, NULL) == IEC104_TCP_OK);
CHECK(IEC104_Slave_Get_Application_Layer_Parameters(NULL) == NULL);
}
/**
* 功能:验证以下场景与约束:仅通过公开门面接入外部事件循环,取得请求、对端地址和只读状态。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。
*/
static void test_external_scheduler(void)
{
IEC104_TcpWaitInfo_t wait;
IEC104_TcpReady_t ready;
IEC104_TcpPeerInfo_t peer;
IEC104_TcpServerStatus_t status;
IEC104_TcpError_t error;
IEC104_SlaveEvent_t event;
uint8_t input[16];
uint32_t i;
service_begin();
CHECK(IEC104_Slave_Get_Remote_Address(service, &peer, NULL) == IEC104_TCP_OK);
CHECK(strcmp(peer.address, "127.0.0.1") == 0 && peer.port == 12000);
CHECK(IEC104_Slave_Prepare(service, &wait, NULL) == IEC104_TCP_OK);
memset(&ready, 0, sizeof(ready));
ready.service_token = wait.service_token;
for (i = 0; i < wait.socket_count; ++i) {
ready.sockets[i] = wait.sockets[i];
ready.sockets[i].events = IEC104_TCP_IO_READ;
}
ready.socket_count = wait.socket_count;
CHECK(IEC104_Build_Iframe(input, 0, 0, interrogation, sizeof(interrogation)) == 16);
push(input, sizeof(input));
CHECK(IEC104_Slave_Process(service, &ready, NULL) == IEC104_TCP_OK);
CHECK(IEC104_Slave_NextEvent(service, &event) == IEC104_TCP_EVENT_READY);
CHECK(event.asdu_result == IEC60870_ASDU_OK);
CHECK(IEC60870_MasterConnection_Send_ACT_CON(&event.connection, &event.asdu, false));
CHECK(IEC104_Slave_Get_Status(service, &status, NULL) == IEC104_TCP_OK);
CHECK(status.connected && status.connection.data_transfer_started);
CHECK(IEC104_Slave_Process(service, NULL, &error) == IEC104_TCP_INVALID_ARGUMENT);
CHECK(error.result == IEC104_TCP_INVALID_ARGUMENT);
CHECK(IEC104_Slave_Prepare(NULL, &wait, &error) == IEC104_TCP_INVALID_HANDLE);
CHECK(error.stage == IEC104_TCP_STAGE_VALIDATE && error.socket_error == 0);
CHECK(IEC104_Slave_Close_Connection(service, NULL, NULL) == IEC104_TCP_INVALID_ARGUMENT);
service_end();
}
/**
* 功能:验证以下场景与约束:主动上报只需Slave和ASDU。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:离线入NORMAL后在连接激活时正常发送。
*/
static void test_offline_enqueue(void)
{
IEC60870_Asdu_t object;
IEC104_TcpServerStatus_t status;
uint8_t bytes[sizeof(asdu)];
service_open();
memcpy(bytes, asdu, sizeof(bytes));
CHECK(IEC60870_Asdu_Create_From_Buffer(&object,
IEC104_Slave_Get_Application_Layer_Parameters(service), bytes, sizeof(bytes)) == IEC60870_ASDU_OK);
CHECK(IEC104_Slave_Enqueue_Event(service, &object) == IEC104_TCP_SUBMIT_OK);
CHECK(fake.sent_bytes == 0);
CHECK(IEC104_Slave_Get_Status(service, &status, NULL) == IEC104_TCP_OK);
CHECK(status.normal_queue.pending_asdu_count == 1);
service_connect();
service_poll();
CHECK(fake.sent_bytes == 22);
CHECK(memcmp(fake.output + 12, asdu, sizeof(asdu)) == 0);
CHECK(IEC104_Slave_Get_Status(service, &status, NULL) == IEC104_TCP_OK);
CHECK(status.normal_queue.pending_asdu_count == 0 && status.normal_queue.stored_asdu_count == 1);
service_end();
}
/**
* 功能:验证以下场景与约束:启动释放必须同时匹配服务身份、TCP代次和活动轮次。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:完整通知FIFO优先让出。
* I_FRAME和Copy_Event保留原轮次,STOP/START后旧业务完成不能重新打开门禁。
*/
static void test_startup_release_identity(void)
{
IEC104_SlaveConfig_t config;
IEC104_SlaveEvent_t event, saved;
IEC104_SlaveEventIdentity_t identity, foreign;
IEC104_TcpServerStatus_t status;
uint8_t input[16];
uint64_t epoch, next_epoch;
memset(&fake, 0, sizeof(fake)); fake.now = 1000U;
service = IEC104_Slave_Create(); CHECK(service != NULL); locate_test_server();
test_transport_config(&config);
config.startup_event_gate = 2U;
CHECK(IEC104_Slave_Init(service, &config, NULL) != IEC104_TCP_OK);
config.startup_event_gate = 1U;
CHECK(IEC104_Slave_Init(service, &config, NULL) == IEC104_TCP_OK);
fake.accept_pending = 1U; service_poll();
CHECK(IEC104_Slave_NextEvent(service, &event) == IEC104_TCP_EVENT_READY && event.transport.activation_id == 0U);
CHECK(IEC104_Slave_Get_Event_Identity(service, &event, &identity));
CHECK(IEC104_Slave_Release_Startup(service, &identity, 0U) == IEC104_TCP_SUBMIT_ERROR);
push(start_act, sizeof(start_act)); service_poll();
CHECK(IEC104_Slave_Get_Status(service, &status, NULL) == IEC104_TCP_OK && status.startup_pending);
epoch = status.activation_id;
CHECK(IEC104_Slave_Release_Startup(service, &identity, epoch) == IEC104_TCP_SUBMIT_WAIT);
CHECK(IEC104_Slave_NextEvent(service, &event) == IEC104_TCP_EVENT_READY &&
event.transport.type == IEC104_TCP_EVENT_ACTIVATED && event.transport.activation_id == epoch);
receive_request(&event, 0U);
CHECK(event.transport.activation_id == epoch && IEC104_Slave_Copy_Event(&saved, &event));
CHECK(saved.transport.activation_id == epoch && IEC104_Slave_Get_Event_Identity(service, &saved, &identity));
CHECK(IEC104_Slave_Query_Idle_Send(service, &identity, 1U) == IEC104_TCP_SUBMIT_WAIT);
CHECK(IEC104_Build_Iframe(input, 1U, 0U, interrogation, sizeof(interrogation)) == 16);
push(input, sizeof(input)); service_poll();
foreign = identity; ++foreign.instance_id;
CHECK(IEC104_Slave_Release_Startup(service, &foreign, epoch) == IEC104_TCP_SUBMIT_ERROR);
CHECK(IEC104_Slave_Release_Startup(service, &identity, epoch) == IEC104_TCP_SUBMIT_WAIT);
CHECK(service_drain() == 1U);
CHECK(IEC104_Slave_Release_Startup(service, &identity, epoch + 1U) == IEC104_TCP_SUBMIT_ERROR);
CHECK(IEC104_Slave_Release_Startup(service, &identity, epoch) == IEC104_TCP_SUBMIT_OK);
CHECK(IEC104_Slave_Get_Status(service, &status, NULL) == IEC104_TCP_OK && !status.startup_pending);
push(stop_act, sizeof(stop_act)); push(start_act, sizeof(start_act)); service_poll();
CHECK(IEC104_Slave_Release_Startup(service, &identity, epoch) == IEC104_TCP_SUBMIT_WAIT);
CHECK(IEC104_Slave_NextEvent(service, &event) == IEC104_TCP_EVENT_READY &&
event.transport.type == IEC104_TCP_EVENT_DEACTIVATED && event.transport.activation_id == epoch);
CHECK(IEC104_Slave_NextEvent(service, &event) == IEC104_TCP_EVENT_READY &&
event.transport.type == IEC104_TCP_EVENT_ACTIVATED && event.transport.activation_id > epoch);
next_epoch = event.transport.activation_id;
CHECK(saved.transport.activation_id == epoch);
CHECK(IEC104_Slave_Release_Startup(service, &identity, saved.transport.activation_id) == IEC104_TCP_SUBMIT_ERROR);
CHECK(IEC104_Slave_Release_Startup(service, &identity, next_epoch) == IEC104_TCP_SUBMIT_OK);
push(stop_act, sizeof(stop_act)); service_poll(); service_drain();
CHECK(IEC104_Slave_Release_Startup(service, &identity, next_epoch) == IEC104_TCP_SUBMIT_ERROR);
service_end();
}
/* ============================================================================
* [STATION/REGISTRY] 共用站点表用例:路由、引用、迭代锁、生命周期与快照
* ============================================================================ */
/**
* 功能:验证以下场景与约束:多于原任务池容量的站点共享一个Slave。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:同IOA的数据源由CA定位到不同context。
*/
static void test_station_registry(void)
{
IEC104_Station_t stations[13] = {0}, duplicate = {0}, boundary = {0};
struct { uint32_t ioa; int value; } points[13];
IEC104_Station_t *current = NULL;
unsigned i;
service = IEC104_Slave_Create();
CHECK(service != NULL && IEC104_Slave_Get_Station_Count(service) == 0U);
for (i = 0U; i < 13U; ++i) {
points[i].ioa = 100U;
points[i].value = (int)i;
CHECK(IEC104_Slave_Add_Station(service, &stations[i], (uint16_t)(i + 1U), &points[i]) == IEC104_STATION_OK);
}
CHECK(IEC104_Slave_Get_Station_Count(service) == 13U);
for (i = 0U; i < 13U; ++i) {
current = IEC104_Slave_Next_Station(service, current);
CHECK(current == &stations[i]);
CHECK(IEC104_Slave_Get_Station(service, (uint16_t)(i + 1U)) == current);
CHECK(IEC104_Station_Get_Common_Address(current) == i + 1U);
CHECK(IEC104_Station_Get_Context(current) == &points[i]);
}
CHECK(IEC104_Slave_Next_Station(service, current) == NULL);
CHECK(IEC104_Slave_Next_Station(service, &duplicate) == NULL);
CHECK(IEC104_Slave_Add_Station(service, &duplicate, 7U, NULL) == IEC104_STATION_DUPLICATE_CA);
CHECK(IEC104_Station_Get_Common_Address(&duplicate) == 0U);
CHECK(IEC104_Slave_Add_Station(service, &stations[0], 100U, NULL) == IEC104_STATION_ALREADY_REGISTERED);
CHECK(IEC104_Station_Get_Context(&stations[0]) == &points[0]);
CHECK(IEC104_Slave_Add_Station(service, &boundary, 65534U, NULL) == IEC104_STATION_OK);
CHECK(IEC104_Slave_Get_Station(service, 65534U) == &boundary);
CHECK(IEC104_Slave_Get_Station(service, IEC104_CA_BROADCAST) == NULL);
CHECK(IEC104_Slave_Get_Station(service, 0U) == NULL);
CHECK(IEC104_Slave_Get_Station(service, 100U) == NULL);
CHECK(IEC104_Slave_Remove_Station(service, &stations[6]) == IEC104_STATION_OK);
CHECK(IEC104_Slave_Next_Station(service, &stations[5]) == &stations[7]);
CHECK(IEC104_Slave_Add_Station(service, &duplicate, 7U, &points[6]) == IEC104_STATION_OK);
CHECK(IEC104_Slave_Get_Station(service, 7U) == &duplicate);
CHECK(IEC104_Slave_Next_Station(service, &boundary) == &duplicate);
for (i = 0U; i < 13U; ++i) {
if (i != 6U) { CHECK(IEC104_Slave_Remove_Station(service, &stations[i]) == IEC104_STATION_OK); }
}
CHECK(IEC104_Slave_Remove_Station(service, &boundary) == IEC104_STATION_OK);
CHECK(IEC104_Slave_Remove_Station(service, &duplicate) == IEC104_STATION_OK);
CHECK(IEC104_Station_Get_Common_Address(&duplicate) == 0U && IEC104_Station_Get_Context(&duplicate) == NULL);
CHECK(IEC104_Slave_Get_Station_Count(service) == 0U && IEC104_Slave_Next_Station(service, NULL) == NULL);
CHECK(IEC104_Slave_Destroy(service, NULL) == IEC104_TCP_OK);
}
/**
* 功能:验证以下场景与约束:引用覆盖延迟业务寿命。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:不占用其他站点,不允许零计数释放或计数回绕。
*/
static void test_station_references(void)
{
IEC104_Station_t first = {0}, second = {0};
service = IEC104_Slave_Create();
CHECK(service != NULL);
CHECK(IEC104_Slave_Acquire_Station(service, &first) == IEC104_STATION_NOT_FOUND);
CHECK(IEC104_Slave_Release_Station(service, &first) == IEC104_STATION_NOT_FOUND);
CHECK(IEC104_Slave_Remove_Station(service, &first) == IEC104_STATION_NOT_FOUND);
CHECK(IEC104_Slave_Add_Station(service, &first, 1U, &first) == IEC104_STATION_OK);
CHECK(IEC104_Slave_Release_Station(service, &first) == IEC104_STATION_INVALID_ARGUMENT);
CHECK(IEC104_Slave_Acquire_Station(service, &first) == IEC104_STATION_OK);
CHECK(IEC104_Slave_Acquire_Station(service, &first) == IEC104_STATION_OK);
/* 从CA路由删除与节点回收分离:已有引用还能按注册编号取回原context,直到最后一次Release。 */
CHECK(IEC104_Slave_Remove_Station(service, &first) == IEC104_STATION_OK);
CHECK(!IEC104_Station_Is_Registered(&first) && !IEC104_Station_Is_Reusable(&first));
CHECK(IEC104_Slave_Get_Station(service, 1U) == NULL);
CHECK(IEC104_Slave_Get_Station_By_Id(service, IEC104_Station_Get_Id(&first)) == &first);
CHECK(IEC104_Station_Get_Context(&first) == &first);
CHECK(IEC104_Slave_Add_Station(service, &second, 2U, NULL) == IEC104_STATION_OK);
CHECK(IEC104_Slave_Remove_Station(service, &second) == IEC104_STATION_OK);
CHECK(IEC104_Slave_Release_Station(service, &first) == IEC104_STATION_OK);
CHECK(IEC104_Slave_Remove_Station(service, &first) == IEC104_STATION_NOT_FOUND);
CHECK(!IEC104_Station_Is_Reusable(&first));
CHECK(IEC104_Slave_Release_Station(service, &first) == IEC104_STATION_OK);
CHECK(IEC104_Station_Is_Reusable(&first));
CHECK(IEC104_Slave_Add_Station(service, &first, 1U, &first) == IEC104_STATION_OK);
first._users = UINT32_MAX; /* 仅测试注入溢出边界,不需要执行数十亿次Acquire。 */
CHECK(IEC104_Slave_Acquire_Station(service, &first) == IEC104_STATION_LIMIT);
CHECK(IEC104_Slave_Remove_Station(service, &first) == IEC104_STATION_OK);
first._users = 0U;
CHECK(IEC104_Slave_Acquire_Station(service, &first) == IEC104_STATION_OK);
CHECK(IEC104_Slave_Release_Station(service, &first) == IEC104_STATION_OK);
CHECK(IEC104_Slave_Release_Station(service, &first) == IEC104_STATION_NOT_FOUND);
CHECK(IEC104_Slave_Destroy(service, NULL) == IEC104_TCP_OK);
}
/**
* 功能:验证以下场景与约束:固定集合允许嵌套读者及站点引用,但在最后一个读者离开前不能增删或销毁。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。
*/
static void test_station_iteration_lock(void)
{
IEC104_Station_t first = {0}, second = {0};
service = IEC104_Slave_Create();
CHECK(service != NULL);
CHECK(IEC104_Slave_Unlock_Stations(service) == IEC104_STATION_INVALID_ARGUMENT);
CHECK(IEC104_Slave_Lock_Stations(service) == IEC104_STATION_OK);
CHECK(IEC104_Slave_Destroy(service, NULL) == IEC104_TCP_INVALID_STATE);
CHECK(IEC104_Slave_Add_Station(service, &first, 1U, NULL) == IEC104_STATION_BUSY);
CHECK(IEC104_Slave_Unlock_Stations(service) == IEC104_STATION_OK);
CHECK(IEC104_Slave_Add_Station(service, &first, 1U, NULL) == IEC104_STATION_OK);
CHECK(IEC104_Slave_Lock_Stations(service) == IEC104_STATION_OK);
CHECK(IEC104_Slave_Lock_Stations(service) == IEC104_STATION_OK);
CHECK(IEC104_Slave_Get_Station(service, 1U) == &first);
CHECK(IEC104_Slave_Next_Station(service, NULL) == &first);
CHECK(IEC104_Slave_Add_Station(service, &second, 2U, NULL) == IEC104_STATION_BUSY);
CHECK(IEC104_Slave_Remove_Station(service, &first) == IEC104_STATION_BUSY);
CHECK(IEC104_Slave_Acquire_Station(service, &first) == IEC104_STATION_OK);
CHECK(IEC104_Slave_Release_Station(service, &first) == IEC104_STATION_OK);
CHECK(IEC104_Slave_Unlock_Stations(service) == IEC104_STATION_OK);
CHECK(IEC104_Slave_Remove_Station(service, &first) == IEC104_STATION_BUSY);
CHECK(IEC104_Slave_Unlock_Stations(service) == IEC104_STATION_OK);
CHECK(IEC104_Slave_Remove_Station(service, &first) == IEC104_STATION_OK);
CHECK(IEC104_Slave_Unlock_Stations(service) == IEC104_STATION_INVALID_ARGUMENT);
CHECK(IEC104_Slave_Destroy(service, NULL) == IEC104_TCP_OK);
}
/**
* 功能:验证以下场景与约束:站点属于服务,不属于某次TCP连接。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:关闭/重启保留,销毁前必须显式解除关联。
*/
static void test_station_lifecycle(void)
{
IEC104_Station_t station = {0};
IEC104_TcpError_t error;
IEC104_SlaveConfig_t config;
service_begin();
CHECK(IEC104_Slave_Add_Station(service, &station, 0U, NULL) == IEC104_STATION_INVALID_ARGUMENT);
CHECK(IEC104_Slave_Add_Station(service, &station, IEC104_CA_BROADCAST, NULL) == IEC104_STATION_INVALID_ARGUMENT);
CHECK(IEC104_Slave_Add_Station(NULL, &station, 1U, NULL) == IEC104_STATION_INVALID_ARGUMENT);
CHECK(IEC104_Slave_Add_Station(service, NULL, 1U, NULL) == IEC104_STATION_INVALID_ARGUMENT);
CHECK(IEC104_Slave_Add_Station(service, &station, 1U, &config) == IEC104_STATION_OK);
CHECK(IEC104_Slave_Close(service, NULL) == IEC104_TCP_OK);
service_drain();
CHECK(IEC104_Slave_Get_Station(service, 1U) == &station);
CHECK(IEC104_Slave_Destroy(service, &error) == IEC104_TCP_INVALID_STATE);
CHECK(error.result == IEC104_TCP_INVALID_STATE && error.stage == IEC104_TCP_STAGE_VALIDATE);
test_transport_config(&config);
CHECK(IEC104_Slave_Init(service, &config, NULL) == IEC104_TCP_OK);
CHECK(IEC104_Station_Get_Context(IEC104_Slave_Get_Station(service, 1U)) == &config);
CHECK(IEC104_Slave_Remove_Station(service, &station) == IEC104_STATION_OK);
service_end();
CHECK(IEC104_Slave_Remove_Station(NULL, &station) == IEC104_STATION_INVALID_ARGUMENT);
CHECK(IEC104_Slave_Acquire_Station(NULL, &station) == IEC104_STATION_INVALID_ARGUMENT);
CHECK(IEC104_Slave_Release_Station(NULL, &station) == IEC104_STATION_INVALID_ARGUMENT);
CHECK(IEC104_Slave_Lock_Stations(NULL) == IEC104_STATION_INVALID_ARGUMENT);
CHECK(IEC104_Slave_Unlock_Stations(NULL) == IEC104_STATION_INVALID_ARGUMENT);
CHECK(IEC104_Slave_Get_Station(NULL, 1U) == NULL && IEC104_Slave_Get_Station_Count(NULL) == 0U);
CHECK(IEC104_Slave_Next_Station(NULL, NULL) == NULL);
CHECK(IEC104_Station_Get_Common_Address(NULL) == 0U && IEC104_Station_Get_Context(NULL) == NULL);
#if IEC104_TCP_SERVER_CAPACITY >= 2U
{
IEC104_Slave_t *other;
IEC104_Station_t foreign = {0};
service = IEC104_Slave_Create();
other = IEC104_Slave_Create();
CHECK(service != NULL && other != NULL);
CHECK(IEC104_Slave_Add_Station(service, &station, 7U, &station) == IEC104_STATION_OK);
CHECK(IEC104_Slave_Add_Station(other, &station, 8U, NULL) == IEC104_STATION_ALREADY_REGISTERED);
CHECK(IEC104_Slave_Add_Station(other, &foreign, 7U, &foreign) == IEC104_STATION_OK);
CHECK(IEC104_Slave_Get_Station(service, 7U) == &station && IEC104_Slave_Get_Station(other, 7U) == &foreign);
CHECK(IEC104_Slave_Acquire_Station(other, &station) == IEC104_STATION_NOT_FOUND);
CHECK(IEC104_Slave_Release_Station(other, &station) == IEC104_STATION_NOT_FOUND);
CHECK(IEC104_Slave_Remove_Station(other, &station) == IEC104_STATION_NOT_FOUND);
CHECK(IEC104_Slave_Next_Station(other, &station) == NULL);
CHECK(IEC104_Slave_Remove_Station(service, &station) == IEC104_STATION_OK);
CHECK(IEC104_Slave_Remove_Station(other, &foreign) == IEC104_STATION_OK);
CHECK(IEC104_Slave_Destroy(other, NULL) == IEC104_TCP_OK);
CHECK(IEC104_Slave_Destroy(service, NULL) == IEC104_TCP_OK);
}
#endif
}
/**
* 功能:遍历不冻结增删。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:旧引用可用,新注册编号不会混入进行中的广播,最后一个快照归还才回收。
*/
static void test_station_snapshot(void)
{
IEC104_Station_t first = {0}, second = {0}, replacement = {0}, added = {0};
IEC104_StationSnapshot_t scan = {0}, nested = {0}, copy;
uint64_t old_id;
service = IEC104_Slave_Create();
CHECK(service != NULL);
CHECK(IEC104_Slave_StationSnapshot_Begin(NULL, &scan) == IEC104_STATION_INVALID_ARGUMENT);
CHECK(IEC104_Slave_StationSnapshot_End(&scan) == IEC104_STATION_INVALID_ARGUMENT);
CHECK(IEC104_Slave_StationSnapshot_Next(&scan) == NULL);
CHECK(IEC104_Slave_Add_Station(service, &first, 1U, &first) == IEC104_STATION_OK);
CHECK(IEC104_Slave_Add_Station(service, &second, 2U, &second) == IEC104_STATION_OK);
old_id = IEC104_Station_Get_Id(&second);
CHECK(IEC104_Slave_StationSnapshot_Begin(service, &scan) == IEC104_STATION_OK);
CHECK(IEC104_Slave_StationSnapshot_Begin(service, &scan) == IEC104_STATION_INVALID_ARGUMENT);
copy = scan;
CHECK(IEC104_Slave_StationSnapshot_Next(&copy) == NULL);
CHECK(IEC104_Slave_StationSnapshot_End(&copy) == IEC104_STATION_INVALID_ARGUMENT);
CHECK(IEC104_Slave_StationSnapshot_Next(&scan) == &first);
CHECK(IEC104_Slave_Remove_Station(service, &second) == IEC104_STATION_OK);
CHECK(!IEC104_Station_Is_Reusable(&second));
CHECK(IEC104_Slave_Add_Station(service, &replacement, 2U, &replacement) == IEC104_STATION_OK);
CHECK(IEC104_Station_Get_Id(&replacement) > old_id);
CHECK(IEC104_Slave_Get_Station_By_Id(service, old_id) == &second);
CHECK(IEC104_Slave_Get_Station(service, 2U) == &replacement);
CHECK(IEC104_Slave_Add_Station(service, &added, 3U, NULL) == IEC104_STATION_OK);
CHECK(IEC104_Slave_StationSnapshot_Begin(service, &nested) == IEC104_STATION_OK);
/* 旧快照跳过已删除站,也不包含后来新增站;新开的嵌套快照可见替代站及新站。 */
CHECK(IEC104_Slave_StationSnapshot_Next(&scan) == NULL);
CHECK(IEC104_Slave_StationSnapshot_End(&scan) == IEC104_STATION_OK);
CHECK(!IEC104_Station_Is_Reusable(&second));
CHECK(IEC104_Slave_StationSnapshot_Next(&nested) == &first);
CHECK(IEC104_Slave_StationSnapshot_Next(&nested) == &replacement);
CHECK(IEC104_Slave_StationSnapshot_Next(&nested) == &added);
CHECK(IEC104_Slave_StationSnapshot_Next(&nested) == NULL);
CHECK(IEC104_Slave_StationSnapshot_End(&nested) == IEC104_STATION_OK);
CHECK(IEC104_Station_Is_Reusable(&second) && IEC104_Slave_Get_Station_By_Id(service, old_id) == NULL);
CHECK(IEC104_Slave_Remove_Station(service, &first) == IEC104_STATION_OK);
CHECK(IEC104_Slave_Remove_Station(service, &replacement) == IEC104_STATION_OK);
CHECK(IEC104_Slave_Remove_Station(service, &added) == IEC104_STATION_OK);
CHECK(IEC104_Slave_StationSnapshot_Begin(service, &scan) == IEC104_STATION_OK);
CHECK(IEC104_Slave_StationSnapshot_Next(&scan) == NULL);
CHECK(IEC104_Slave_Destroy(service, NULL) == IEC104_TCP_INVALID_STATE);
CHECK(IEC104_Slave_StationSnapshot_End(&scan) == IEC104_STATION_OK);
CHECK(IEC104_Slave_Destroy(service, NULL) == IEC104_TCP_OK);
}
/* Rejection helpers retain the real transport, queue and sequence handling. */
static const uint8_t reject_clock[] = {103, 1, 6, 0x31, 1, 0, 0, 0, 0, 0, 0, 0, 12, 28, 10, 26};
static const uint8_t reject_read[] = {102, 1, 5, 0x32, 1, 0, 0xe9, 3, 0};
/* ============================================================================
* [REJECT/FIXTURE] 同步拒绝专属辅助:请求输入、应答收集与传输收敛
* ============================================================================ */
/**
* 功能:按指定 N(S)、N(R) 封装 I 帧,核对长度后注入模拟网络输入。
* 输入参数:ns——I 帧发送序号 N(S);nr——I 帧接收确认序号 N(R);bytes——报文字节缓冲区(只读);length——字节长度。
* 输出参数:无。
* 返回值:无。
* 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。
*/
static void reject_push(uint16_t ns, uint16_t nr, const uint8_t *bytes, size_t length)
{
uint8_t frame[IEC104_MAX_APDU_LEN];
int built = IEC104_Build_Iframe(frame, ns, nr, bytes, (uint16_t)length);
CHECK(built == (int)(length + IEC104_APCI_LEN));
push(frame, (size_t)built);
}
/**
* 功能:读取一条已解析I帧通知,供拒绝入口测试单独控制请求到达与应答交接的先后。
* 输入参数:event——业务或传输事件。
* 输出参数:event——业务或传输事件。
* 返回值:无。
* 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。
*/
static void reject_take(IEC104_SlaveEvent_t *event)
{
CHECK(IEC104_Slave_NextEvent(service, event) == IEC104_TCP_EVENT_READY);
CHECK(event->transport.type == IEC104_TCP_EVENT_I_FRAME && event->asdu_result == IEC60870_ASDU_OK);
}
/**
* 功能:返回fake.output内的借用ASDU视图,只筛I帧。
* 输入参数:frames——按线上顺序排列的 ASDU 视图数组;lengths——各 ASDU 的长度数组;capacity——调用方提供的缓冲容量。
* 输出参数:frames——按线上顺序排列的 ASDU 视图数组;lengths——各 ASDU 的长度数组。
* 返回值:本次收集或统计到的有效业务帧数量。
* 说明:清空或重用输出缓冲前必须完成断言。
*/
static unsigned reject_output(const uint8_t *frames[], size_t lengths[], unsigned capacity)
{
size_t offset = 0U;
unsigned count = 0U;
while (offset < fake.sent_bytes) {
const uint8_t *frame = fake.output + offset;
size_t length = frame[1] + 2U;
CHECK(frame[0] == 0x68 && length >= IEC104_APCI_LEN && offset + length <= fake.sent_bytes);
if ((frame[2] & 1U) == 0U) {
CHECK(count < capacity);
frames[count] = frame + IEC104_APCI_LEN;
lengths[count++] = length - IEC104_APCI_LEN;
}
offset += length;
}
return count;
}
/**
* 功能:有界推进网络并丢弃通知,排空正常提交尾部。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:不发送主站ACK,也不表示对端确认。
*/
static void reject_settle(void)
{
unsigned i;
for (i = 0U; i < 8U; ++i) { service_poll(); service_drain(); }
}
/* ============================================================================
* [REJECT/CASES] 同步拒绝44..49:回显、参数、拥塞、启停及故障
* ============================================================================ */
/**
* 功能:验证44..49的否定回显完整保留请求字节,覆盖TEST置位及清零。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。
*/
static void test_reject_echo(void)
{
unsigned variant;
for (variant = 0U; variant < 12U; ++variant) {
unsigned cause = 44U + variant / 2U;
IEC104_SlaveEvent_t event, before;
uint8_t request[IEC104_MAX_ASDU_LEN];
const uint8_t *frames[2];
size_t lengths[2];
memset(request, 0x5a, sizeof(request));
request[0] = 200U; request[1] = 0x82U; request[2] = (uint8_t)(6U | ((variant & 1U) << 7));
service_begin();
reject_push(0, 0, request, sizeof(request)); service_poll(); reject_take(&event);
/* Seed OK so an implementation that resets last-submit to ERROR is caught. */
CHECK(IEC60870_MasterConnection_Send_ASDU(&event.connection, &event.asdu));
before = event;
CHECK(IEC104_Slave_Reject_Request(service, &event, (int)cause) == IEC104_TCP_SUBMIT_OK);
CHECK(memcmp(&event, &before, sizeof(event)) == 0);
CHECK(IEC104_Slave_Get_Last_Submit_Result(&event.connection) == IEC104_TCP_SUBMIT_OK);
CHECK(reject_output(frames, lengths, 2) == 2U && lengths[1] == sizeof(request));
check_reply(frames[1], request, sizeof(request), (uint8_t)(0x40U | (request[2] & 0x80U) | cause));
service_end();
}
}
/**
* 功能:覆盖非法COT、损坏的事件视图及错误属主。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:失败须保持原事件和线上输出不变。
*/
static void test_reject_invalid(void)
{
IEC104_SlaveEvent_t event, before, invalid;
static const int causes[] = {-1, 7, 43, 50, 63, 64, 256};
size_t sent, i;
service_begin(); receive_request(&event, 0); before = event; sent = fake.sent_bytes;
CHECK(IEC104_Slave_Reject_Request(NULL, &event, 44) == IEC104_TCP_SUBMIT_ERROR);
CHECK(IEC104_Slave_Reject_Request(service, NULL, 44) == IEC104_TCP_SUBMIT_ERROR);
for (i = 0U; i < sizeof(causes) / sizeof(causes[0]); ++i) {
CHECK(IEC104_Slave_Reject_Request(service, &event, causes[i]) == IEC104_TCP_SUBMIT_ERROR);
}
invalid = event; /* Deliberately invalid self-references. */
CHECK(IEC104_Slave_Reject_Request(service, &invalid, 44) == IEC104_TCP_SUBMIT_ERROR);
CHECK(IEC104_Slave_Copy_Event(&invalid, &event));
invalid.asdu_result = IEC60870_ASDU_ERROR;
CHECK(IEC104_Slave_Reject_Request(service, &invalid, 44) == IEC104_TCP_SUBMIT_ERROR);
CHECK(IEC104_Slave_Copy_Event(&invalid, &event)); ++invalid._owner_serial;
CHECK(IEC104_Slave_Reject_Request(service, &invalid, 44) == IEC104_TCP_SUBMIT_ERROR);
#if IEC104_TCP_SERVER_CAPACITY > 1
{
IEC104_Slave_t *other = IEC104_Slave_Create();
CHECK(other != NULL);
CHECK(IEC104_Slave_Reject_Request(other, &event, 44) == IEC104_TCP_SUBMIT_ERROR);
CHECK(IEC104_Slave_Destroy(other, NULL) == IEC104_TCP_OK);
}
#endif
CHECK(fake.sent_bytes == sent && memcmp(&event, &before, sizeof(event)) == 0);
service_end();
}
/**
* 功能:验证以下场景与约束:Ordinary unread I events must not block an immediate rejection.
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。
*/
static void test_reject_batch(void)
{
unsigned mode, i;
for (mode = 0U; mode < 3U; ++mode) {
const uint8_t *requests[] = {reject_clock, reject_read};
size_t sizes[] = {sizeof(reject_clock), sizeof(reject_read)};
const uint8_t *frames[2]; size_t lengths[2];
IEC104_SlaveEvent_t event, before;
IEC104_TcpServerStatus_t status;
if (mode == 1U) { requests[0] = reject_read; sizes[0] = sizeof(reject_read);
requests[1] = reject_clock; sizes[1] = sizeof(reject_clock); }
if (mode == 2U) { requests[1] = reject_clock; sizes[1] = sizeof(reject_clock); }
service_begin();
for (i = 0U; i < 2U; ++i) { reject_push((uint16_t)i, 0, requests[i], sizes[i]); }
service_poll();
for (i = 0U; i < 2U; ++i) {
reject_take(&event); before = event;
CHECK(IEC104_Slave_Get_Status(service, &status, NULL) == IEC104_TCP_OK);
CHECK(status.pending_state_event_count == 0U && status.pending_event_count == 1U - i);
CHECK(IEC104_Slave_Reject_Request(service, &event, 44) == IEC104_TCP_SUBMIT_OK);
CHECK(memcmp(&event, &before, sizeof(event)) == 0);
}
reject_settle();
CHECK(reject_output(frames, lengths, 2) == 2U);
for (i = 0U; i < 2U; ++i) {
CHECK(lengths[i] == sizes[i]); check_reply(frames[i], requests[i], sizes[i], 0x6c);
}
CHECK(IEC104_Slave_Get_Status(service, &status, NULL) == IEC104_TCP_OK && status.connected);
service_end();
}
}
/**
* 功能:验证以下场景与约束:k=1 queues the second response。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:reusing the source cannot change the saved bytes.
*/
static void test_reject_window(void)
{
IEC104_SlaveEvent_t event;
IEC104_TcpServerStatus_t status;
const uint8_t *frames[2]; size_t lengths[2];
uint8_t unknown[IEC104_MAX_ASDU_LEN];
memset(unknown, 0x5a, sizeof(unknown));
unknown[0] = 200U; unknown[1] = 0U; unknown[2] = 0x86U;
service_open_with_window(1U); service_connect();
reject_push(0, 0, reject_clock, sizeof(reject_clock));
reject_push(1, 0, unknown, sizeof(unknown)); service_poll();
reject_take(&event); CHECK(IEC104_Slave_Reject_Request(service, &event, 44) == IEC104_TCP_SUBMIT_OK);
reject_take(&event); CHECK(IEC104_Slave_Reject_Request(service, &event, 44) == IEC104_TCP_SUBMIT_OK);
memset(&event, 0xa5, sizeof(event));
CHECK(IEC104_Slave_Get_Status(service, &status, NULL) == IEC104_TCP_OK);
CHECK(status.high_queue.pending_asdu_count == 1U && reject_output(frames, lengths, 2) == 1U);
push_ack(1); reject_settle();
CHECK(reject_output(frames, lengths, 2) == 2U && lengths[1] == sizeof(unknown));
check_reply(frames[1], unknown, sizeof(unknown), 0xec);
service_end();
}
/**
* 功能:验证以下场景与约束:Real HIGH exhaustion returns WAIT, retaining existing entries and the input event.
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。
*/
static void test_reject_full(void)
{
IEC104_SlaveEvent_t event, before_event;
IEC104_TcpServerStatus_t before, after;
unsigned accepted;
uint8_t high_before[IEC104_TCP_HIGH_CAPACITY];
service_begin(); receive_request(&event, 0); fake.send_blocked = 1;
for (accepted = 0U; accepted < 200U; ++accepted) {
if (!IEC60870_MasterConnection_Send_ASDU(&event.connection, &event.asdu)) { break; }
}
CHECK(accepted > 0U && accepted < 200U);
CHECK(IEC104_Slave_Get_Last_Submit_Result(&event.connection) == IEC104_TCP_SUBMIT_WAIT);
before_event = event; memcpy(high_before, sut->high_bytes, sizeof(high_before));
CHECK(IEC104_Slave_Get_Status(service, &before, NULL) == IEC104_TCP_OK);
CHECK(IEC104_Slave_Reject_Request(service, &event, 44) == IEC104_TCP_SUBMIT_WAIT);
CHECK(memcmp(&event, &before_event, sizeof(event)) == 0);
CHECK(memcmp(high_before, sut->high_bytes, sizeof(high_before)) == 0);
CHECK(IEC104_Slave_Get_Status(service, &after, NULL) == IEC104_TCP_OK && after.connected);
CHECK(before.high_queue.used_bytes == after.high_queue.used_bytes &&
before.high_queue.pending_asdu_count == after.high_queue.pending_asdu_count);
fake.send_blocked = 0; reject_settle();
service_end();
}
/**
* 功能:验证以下场景与约束:State counts exclude CONNECTED。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:unread STOP/START blocks an old immediate response.
*/
static void test_reject_state_gate(void)
{
unsigned restart;
for (restart = 0U; restart < 2U; ++restart) {
IEC104_SlaveEvent_t event, before;
IEC104_TcpServerStatus_t status;
const uint8_t *frames[1]; size_t lengths[1];
service_open(); fake.accept_pending = 1; service_poll();
CHECK(IEC104_Slave_Get_Status(service, &status, NULL) == IEC104_TCP_OK);
CHECK(status.pending_event_count == 1U && status.pending_state_event_count == 0U);
CHECK(IEC104_Slave_NextEvent(service, &event) == IEC104_TCP_EVENT_READY);
CHECK(IEC104_Slave_Reject_Request(service, &event, 44) == IEC104_TCP_SUBMIT_ERROR);
push(start_act, sizeof(start_act)); service_poll();
CHECK(IEC104_Slave_Get_Status(service, &status, NULL) == IEC104_TCP_OK);
CHECK(status.pending_state_event_count == 1U); CHECK(service_drain() == 1U);
reject_push(0, 0, reject_clock, sizeof(reject_clock)); push(stop_act, sizeof(stop_act));
if (restart) { push(start_act, sizeof(start_act)); }
service_poll(); reject_take(&event); before = event;
CHECK(IEC104_Slave_Get_Status(service, &status, NULL) == IEC104_TCP_OK);
/* 即使STOP后又START,尚未消费的启停通知仍阻止旧请求同步拒绝;不能只检查当前激活位。 */
CHECK(status.pending_state_event_count == 1U + restart);
CHECK(IEC104_Slave_Reject_Request(service, &event, 44) == IEC104_TCP_SUBMIT_ERROR);
CHECK(memcmp(&event, &before, sizeof(event)) == 0 && reject_output(frames, lengths, 1) == 0U);
CHECK(IEC104_Slave_NextEvent(service, &event) == IEC104_TCP_EVENT_READY);
CHECK(event.transport.type == IEC104_TCP_EVENT_DEACTIVATED);
CHECK(IEC104_Slave_Get_Status(service, &status, NULL) == IEC104_TCP_OK);
CHECK(status.pending_state_event_count == restart);
service_drain();
if (!restart) { push(start_act, sizeof(start_act)); service_poll(); service_drain(); }
reject_push(1, 0, reject_read, sizeof(reject_read)); service_poll(); reject_take(&event);
CHECK(IEC104_Slave_Reject_Request(service, &event, 44) == IEC104_TCP_SUBMIT_OK);
CHECK(reject_output(frames, lengths, 1) == 1U);
service_end();
}
}
/**
* 功能:验证以下场景与约束:STOP invalidates queued replies。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:a repeated START preserves them without a state event.
*/
static void test_reject_queued_lifecycle(void)
{
unsigned stop;
for (stop = 0U; stop < 2U; ++stop) {
IEC104_SlaveEvent_t event;
IEC104_TcpServerStatus_t status;
const uint8_t *frames[2]; size_t lengths[2];
service_open_with_window(1U); service_connect();
reject_push(0, 0, reject_clock, sizeof(reject_clock));
reject_push(1, 0, reject_read, sizeof(reject_read)); service_poll();
reject_take(&event); CHECK(IEC104_Slave_Reject_Request(service, &event, 44) == IEC104_TCP_SUBMIT_OK);
reject_take(&event); CHECK(IEC104_Slave_Reject_Request(service, &event, 44) == IEC104_TCP_SUBMIT_OK);
push(stop ? stop_act : start_act, sizeof(start_act)); service_poll();
CHECK(IEC104_Slave_Get_Status(service, &status, NULL) == IEC104_TCP_OK);
CHECK(status.pending_state_event_count == stop && status.high_queue.pending_asdu_count == 1U - stop);
service_drain(); push_ack(1); reject_settle();
CHECK(reject_output(frames, lengths, 2) == 2U - stop);
if (stop) {
push(start_act, sizeof(start_act)); service_poll(); service_drain();
reject_push(2, 1, reject_read, sizeof(reject_read)); service_poll(); reject_take(&event);
CHECK(IEC104_Slave_Reject_Request(service, &event, 44) == IEC104_TCP_SUBMIT_OK);
}
CHECK(reject_output(frames, lengths, 2) == 2U);
check_reply(frames[1], reject_read, sizeof(reject_read), 0x6c);
service_end();
}
}
/**
* 功能:验证以下场景与约束:先换连接,再重建服务,分别验证旧事件不能在新代次或复用实例上生成否定应答。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。
*/
static void test_reject_stale(void)
{
IEC104_SlaveEvent_t old_event, current;
size_t sent;
service_begin(); receive_request(&old_event, 0);
CHECK(IEC104_Slave_Close_Connection(service, &old_event, NULL) == IEC104_TCP_OK);
service_drain(); service_connect(); receive_request(&current, 0); sent = fake.sent_bytes;
CHECK(IEC104_Slave_Reject_Request(service, &old_event, 44) == IEC104_TCP_SUBMIT_ERROR);
CHECK(fake.sent_bytes == sent);
CHECK(IEC104_Slave_Reject_Request(service, &current, 44) == IEC104_TCP_SUBMIT_OK);
service_end(); service_begin(); receive_request(&current, 0); sent = fake.sent_bytes;
CHECK(IEC104_Slave_Reject_Request(service, &old_event, 44) == IEC104_TCP_SUBMIT_ERROR);
CHECK(fake.sent_bytes == sent);
service_end();
}
/**
* 功能:验证以下场景与约束:注入队列未初始化故障,检查拒绝入口报告FATAL且不改请求、不输出回复。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:恢复字段只为清理。
*/
static void test_reject_fatal(void)
{
IEC104_SlaveEvent_t event, before;
size_t sent;
service_begin(); receive_request(&event, 0); before = event; sent = fake.sent_bytes;
sut->queue_initialized = 0U;
CHECK(IEC104_Slave_Reject_Request(service, &event, 44) == IEC104_TCP_SUBMIT_FATAL);
CHECK(memcmp(&event, &before, sizeof(event)) == 0 && fake.sent_bytes == sent);
sut->queue_initialized = 1U; /* Restore the injected fault only for cleanup; do not retry. */
service_end();
}
/* ============================================================================
* [ENTRY/MAIN] 测试入口:公共层、104服务、站点及同步拒绝
* ============================================================================ */
/**
* 功能:测试入口:公共层、104服务、站点及同步拒绝
* 输入参数:无。
* 输出参数:无。
* 返回值:正常完成返回 0;参数、运行或断言失败以非零状态结束进程。
* 说明:本辅助入口用于构造或核对上述测试场景,相关状态保存在当前测试夹具中。
*/
int main(void)
{
/* [RUN/COMMON] 公共ASDU视图与应答分派 */
test_mutable_views();
test_common_dispatch();
/* [RUN/SLAVE] 104应答、身份和生命周期 */
test_event_replies();
test_constructed_asdu();
test_wait_and_retry();
test_invalid_inputs();
test_identity_response_storage();
test_identity_response_wait();
test_identity_response_validation();
test_event_identity();
test_request_state();
test_stale_generation();
test_fatal_result();
test_deferred_event_copy();
test_service_reuse();
test_lifecycle();
test_external_scheduler();
test_offline_enqueue();
test_startup_release_identity();
/* [RUN/STATION] 共用站点表 */
test_station_registry();
test_station_references();
test_station_iteration_lock();
test_station_lifecycle();
test_station_snapshot();
/* [RUN/REJECT] 同步拒绝44..49 */
test_reject_echo();
test_reject_invalid();
test_reject_batch();
test_reject_window();
test_reject_full();
test_reject_state_gate();
test_reject_queued_lifecycle();
test_reject_stale();
test_reject_fatal();
puts("Slave service: 33 groups passed (replies, identities, startup gate, stations, lifecycle, backpressure, rejection)");
return 0;
}