1761 lines
88 KiB
C
1761 lines
88 KiB
C
/* 共用子站发送接口回归:复用可控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, ¶meters, 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, ©_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, ©_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(¤t, 0);
|
||
CHECK(old_event.transport.generation != current.transport.generation);
|
||
CHECK(IEC104_Slave_Get_Event_Identity(service, &old_event, ¤t_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, ¤t, ¤t_identity));
|
||
CHECK(IEC104_Slave_Check_Request(service, ¤t_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, ¤t.asdu) == IEC104_TCP_SUBMIT_ERROR);
|
||
CHECK(IEC104_Slave_Send_Response_Tracked(service, &old_identity, ¤t.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(¤t.connection, ¤t.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(¤t, 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(¤t.connection, ¤t.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(¤t, 0);
|
||
CHECK(IEC104_Slave_Get_Event_Identity(service, ¤t, &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, ¤t.asdu) == IEC104_TCP_SUBMIT_ERROR);
|
||
CHECK(IEC104_Slave_Send_Response_Tracked(service, &old_identity, ¤t.asdu, NULL) == IEC104_TCP_SUBMIT_ERROR);
|
||
CHECK(fake.sent_bytes == sent);
|
||
CHECK(IEC60870_MasterConnection_Send_ACT_CON(¤t.connection, ¤t.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(©) == NULL);
|
||
CHECK(IEC104_Slave_StationSnapshot_End(©) == 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(¤t, 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, ¤t, 44) == IEC104_TCP_SUBMIT_OK);
|
||
service_end(); service_begin(); receive_request(¤t, 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;
|
||
}
|