2261 lines
106 KiB
C
2261 lines
106 KiB
C
/* 突发上送专项:可控Net配合真实服务队列,分别检查入队原文、网络写出和ACK后释放。
|
||
* 本编译单元直接包含TcpServer与Spontaneous实现,构建时不能再链接这两份实现;
|
||
* 其他库源码正常链接。测试不使用真实socket,也不设置宿主系统时钟。
|
||
*/
|
||
/*
|
||
* 文件内导航(搜索方括号标记;Suite:Spontaneous):
|
||
* 复用公共fake Net;直接包含Spontaneous实现以注入查询/入队故障。sp_*辅助只在本专项共用。
|
||
* 按输入校验、时间与基准、编码与分帧、队列覆盖、生命周期归拢;专用辅助先于使用它的用例。
|
||
* [COMMON/BASE] 公共基础:依赖、编译选项与断言入口
|
||
* [SPONTANEOUS/HOOKS] 专属注入:单调时钟、入队回显、查询失败及模块实现包含
|
||
* [COMMON/FIXTURE] 专项共用辅助:服务、站点、变化对象、连接和线上帧读取
|
||
* [SPONTANEOUS/VALIDATION] 输入校验及辅助:前置条件、品质、配置与实例池
|
||
* [SPONTANEOUS/TIME] 时间用例及辅助:UTC、单调时间、一致快照与WAIT重试
|
||
* [SPONTANEOUS/TIME_BASE] 时间基准生命周期:同步状态、老化和清除
|
||
* [SPONTANEOUS/BASE_ENCODING] 基础监视类型:编码、帧上限、分段、重复IOA与部分提交
|
||
* [SPONTANEOUS/EXTENDED] 扩展监视类型:累计量、成组单点、无品质值和保护事件
|
||
* [SPONTANEOUS/OVERWRITE] 覆盖用例:待发/已提交原文、双报保留与计数失败
|
||
* [SPONTANEOUS/LIFECYCLE] 会话用例:断线、重发、ACK与服务恢复
|
||
* [ENTRY/MAIN] 测试入口:配置、编码、时间、覆盖及会话
|
||
* 函数定义按主题排列;main保留原测试顺序,RUN标记细分执行组。
|
||
*/
|
||
|
||
/* ============================================================================
|
||
* [COMMON/BASE] 公共基础:依赖、编译选项与断言入口
|
||
* ============================================================================ */
|
||
#include "iec104_test_config.h"
|
||
#include "iec104_tcp_fixture.h"
|
||
|
||
#include "IEC104_Spontaneous.h"
|
||
#include <float.h>
|
||
#include <math.h>
|
||
|
||
/* ============================================================================
|
||
* [SPONTANEOUS/HOOKS] 专属注入:单调时钟、入队回显、查询失败及模块实现包含
|
||
* ============================================================================ */
|
||
/* *_at是从1开始的调用序号,0表示不注入;设为当前计数+N可定位一次Publish的
|
||
* 前置检查或提交后统计。sp_frames只记成功交给NORMAL的原文,不等同线上已写出。 */
|
||
static unsigned sp_query_count, sp_query_fail_at, sp_query_invalid_at, sp_query_inconsistent_at;
|
||
static IEC104_TcpResult_t sp_query_failure;
|
||
static struct { uint16_t length; uint8_t bytes[IEC104_MAX_ASDU_LEN]; IEC104_BusinessPriority_t priority; } sp_frames[512];
|
||
static unsigned sp_frame_count, sp_enqueue_count, sp_enqueue_fail_at;
|
||
static IEC104_TcpSubmitResult_t sp_enqueue_failure;
|
||
static unsigned sp_now_reads;
|
||
static uint64_t sp_now_step;
|
||
|
||
/**
|
||
* 功能:每次取时后递增fake.now,用读取次数验证一次Publish只采样一个共同时间基准。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:本次采样的时钟毫秒值。
|
||
* 说明:与宿主墙钟无关的测试路径使用夹具时基;时间推进方式由当前用例控制。
|
||
*/
|
||
static uint64_t SpTest_Now(void)
|
||
{
|
||
uint64_t now = fake.now;
|
||
++sp_now_reads;
|
||
fake.now += sp_now_step;
|
||
return now;
|
||
}
|
||
|
||
/**
|
||
* 功能:指定调用可返回WAIT/ERROR/FATAL。
|
||
* 输入参数:slave——被测 Slave 实例;asdu_value——待提交的 ASDU;priority——存储或业务优先级。
|
||
* 输出参数:无。
|
||
* 返回值:发送提交结果,区分接收成功、WAIT、ERROR 与 FATAL。
|
||
* 说明:其余仍走真实Slave和NORMAL覆盖策略。
|
||
* 仅成功后复制原文,避免把未被发送层接手的帧记入预期序列。
|
||
*/
|
||
static IEC104_TcpSubmitResult_t SpTest_Enqueue(IEC104_Slave_t *slave, IEC60870_Asdu_t *asdu_value,
|
||
IEC104_BusinessPriority_t priority)
|
||
{
|
||
IEC104_TcpSubmitResult_t result;
|
||
++sp_enqueue_count;
|
||
if (sp_enqueue_count == sp_enqueue_fail_at) { return sp_enqueue_failure; }
|
||
result = IEC104_Slave_Enqueue_Event_Priority(slave, asdu_value, priority);
|
||
if (result == IEC104_TCP_SUBMIT_OK) {
|
||
CHECK(sp_frame_count < sizeof(sp_frames) / sizeof(sp_frames[0]));
|
||
CHECK(asdu_value->length <= sizeof(sp_frames[0].bytes));
|
||
sp_frames[sp_frame_count].length = asdu_value->length;
|
||
sp_frames[sp_frame_count].priority = priority;
|
||
memcpy(sp_frames[sp_frame_count].bytes, asdu_value->buffer, asdu_value->length);
|
||
++sp_frame_count;
|
||
}
|
||
return result;
|
||
}
|
||
|
||
/**
|
||
* 功能:记录成功进入独立SOE缓存的原文,并复用普通提交的故障注入序号。
|
||
* 输入参数:slave——从站;asdu_value——单对象CP56帧;priority——业务优先级;deferred——是否保留未决占位。
|
||
* 输出参数:ticket——成功时由真实接口填写的占位身份,可按接口约定为空。
|
||
* 返回值:真实SOE提交或指定故障的结果。
|
||
* 说明:只记录已接手帧,便于验证逐对象交接、部分提交和占位冻结时标。
|
||
*/
|
||
static IEC104_TcpSubmitResult_t SpTest_Enqueue_Soe(IEC104_Slave_t *slave, IEC60870_Asdu_t *asdu_value,
|
||
IEC104_BusinessPriority_t priority, bool deferred, IEC104_SoeTicket_t *ticket)
|
||
{
|
||
IEC104_TcpSubmitResult_t result;
|
||
++sp_enqueue_count;
|
||
if (sp_enqueue_count == sp_enqueue_fail_at) { return sp_enqueue_failure; }
|
||
result = IEC104_Slave_Enqueue_Soe(slave, asdu_value, priority, deferred, ticket);
|
||
if (result == IEC104_TCP_SUBMIT_OK) {
|
||
CHECK(sp_frame_count < sizeof(sp_frames) / sizeof(sp_frames[0]));
|
||
CHECK(asdu_value->length <= sizeof(sp_frames[0].bytes));
|
||
sp_frames[sp_frame_count].length = asdu_value->length;
|
||
sp_frames[sp_frame_count].priority = priority;
|
||
memcpy(sp_frames[sp_frame_count].bytes, asdu_value->buffer, asdu_value->length);
|
||
++sp_frame_count;
|
||
}
|
||
return result;
|
||
}
|
||
|
||
/**
|
||
* 功能:分别注入查询返回错误、无有效队列快照、计数自相矛盾三类故障。
|
||
* 输入参数:slave——被测 Slave 实例(只读);status——状态快照;error——底层错误码存储。
|
||
* 输出参数:status——状态快照;error——底层错误码存储。
|
||
* 返回值:真实传输接口或故障注入产生的 TCP 操作结果。
|
||
* 说明:查询次数区分发布前准入与成功入队后的统计,避免把统计失败误报为提交失败。
|
||
*/
|
||
static IEC104_TcpResult_t SpTest_GetStatus(const IEC104_Slave_t *slave,
|
||
IEC104_TcpServerStatus_t *status, IEC104_TcpError_t *error)
|
||
{
|
||
IEC104_TcpResult_t result;
|
||
++sp_query_count;
|
||
if (sp_query_count == sp_query_fail_at) {
|
||
/* A failed query gives no usable snapshot. These bytes deliberately
|
||
* resemble a closed service, so only the return code may classify it. */
|
||
memset(status, 0, sizeof(*status));
|
||
return sp_query_failure;
|
||
}
|
||
result = IEC104_Slave_Get_Status(slave, status, error);
|
||
if (result == IEC104_TCP_OK && sp_query_count == sp_query_invalid_at) {
|
||
status->asdu_queue_status_valid = 0U;
|
||
}
|
||
if (result == IEC104_TCP_OK && sp_query_count == sp_query_inconsistent_at) {
|
||
status->normal_queue.pending_asdu_count = status->normal_queue.stored_asdu_count + 1U;
|
||
}
|
||
return result;
|
||
}
|
||
|
||
/* 宏替换仅作用于本次包含的Spontaneous实现;前面的钩子函数仍调用真实Slave。
|
||
* 包含后立即恢复名称,后续测试可直接查询传输层而不消耗注入调用序号。 */
|
||
#define IEC104_Slave_Get_Status SpTest_GetStatus
|
||
#define IEC104_Slave_Enqueue_Event_Priority SpTest_Enqueue
|
||
#define IEC104_Slave_Enqueue_Soe SpTest_Enqueue_Soe
|
||
#define IEC104_Net_Now_Ms SpTest_Now
|
||
#include "../104/business/IEC104_Spontaneous.c"
|
||
#undef IEC104_Slave_Get_Status
|
||
#undef IEC104_Slave_Enqueue_Event_Priority
|
||
#undef IEC104_Slave_Enqueue_Soe
|
||
#undef IEC104_Net_Now_Ms
|
||
|
||
/* ============================================================================
|
||
* [COMMON/FIXTURE] 专项共用辅助:服务、站点、变化对象、连接和线上帧读取
|
||
* ============================================================================ */
|
||
static IEC104_Slave_t *sp_slave;
|
||
static IEC104_Spontaneous_t *sp_publisher;
|
||
static IEC104_Station_t sp_stations[2];
|
||
|
||
/**
|
||
* 功能:突发模块没有Handle_Event。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:此处只消费Slave通知,解除事件队列对传输推进的背压。
|
||
*/
|
||
static void sp_drain(void)
|
||
{
|
||
IEC104_SlaveEvent_t event;
|
||
IEC104_TcpEventResult_t result;
|
||
while ((result = IEC104_Slave_NextEvent(sp_slave, &event)) == IEC104_TCP_EVENT_READY) {}
|
||
CHECK(result == IEC104_TCP_EVENT_EMPTY);
|
||
}
|
||
|
||
/**
|
||
* 功能:初始化真实服务并定位fixture中的服务实例。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:扩大协议期限以隔离发布与时标断言。
|
||
* 不建立连接,允许同一辅助用于离线发布及Close后的重新Init。
|
||
*/
|
||
static void sp_initialize(void)
|
||
{
|
||
IEC104_SlaveConfig_t config;
|
||
unsigned i;
|
||
test_transport_config(&config);
|
||
config.protocol.link.k = IEC104_TCP_RECORD_CAPACITY;
|
||
config.protocol.link.t1_ms = 600000U;
|
||
config.protocol.link.t3_ms = 600000U;
|
||
config.protocol.local_send_timeout_ms = 600000U;
|
||
CHECK(IEC104_Slave_Init(sp_slave, &config, NULL) == IEC104_TCP_OK);
|
||
sut = NULL;
|
||
for (i = 0U; i < IEC104_TCP_SERVER_CAPACITY; ++i) {
|
||
if (server_pool[i].in_use) { sut = &server_pool[i].server; break; }
|
||
}
|
||
CHECK(sut != NULL);
|
||
}
|
||
|
||
/**
|
||
* 功能:建立两个已注册站,但不自动建立TCP连接,便于验证离线发布。
|
||
* 输入参数:initialized——是否完成初始化交接;custom——可选文件服务配置(只读)。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:initialized=false只创建句柄和业务实例,留给用例检查服务尚未Init的前置条件。
|
||
*/
|
||
static void sp_open(bool initialized, const IEC104_SpontaneousConfig_t *custom)
|
||
{
|
||
IEC104_SpontaneousConfig_t config;
|
||
memset(&fake, 0, sizeof(fake));
|
||
memset(sp_stations, 0, sizeof(sp_stations));
|
||
fake.now = 1000U;
|
||
sp_query_count = sp_query_fail_at = sp_query_invalid_at = 0U;
|
||
sp_query_inconsistent_at = 0U;
|
||
sp_frame_count = sp_enqueue_count = sp_enqueue_fail_at = 0U;
|
||
sp_enqueue_failure = IEC104_TCP_SUBMIT_WAIT;
|
||
sp_now_reads = 0U;
|
||
sp_now_step = 0U;
|
||
sp_query_failure = IEC104_TCP_INTERNAL_ERROR;
|
||
sp_slave = IEC104_Slave_Create();
|
||
CHECK(sp_slave != NULL);
|
||
CHECK(IEC104_Slave_Add_Station(sp_slave, &sp_stations[0], 0x1234U, NULL) == IEC104_STATION_OK);
|
||
CHECK(IEC104_Slave_Add_Station(sp_slave, &sp_stations[1], 2U, NULL) == IEC104_STATION_OK);
|
||
test_spontaneous_config(&config);
|
||
config.originator_address = 0x56U;
|
||
sp_publisher = IEC104_Spontaneous_Create(sp_slave, custom != NULL ? custom : &config);
|
||
CHECK(sp_publisher != NULL);
|
||
if (initialized) { sp_initialize(); }
|
||
}
|
||
|
||
/**
|
||
* 功能:关闭服务、读空回执后销毁发布实例。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:移除站点并检查可复用,避免fixture清零掩盖泄漏。
|
||
*/
|
||
static void sp_close(void)
|
||
{
|
||
unsigned i;
|
||
CHECK(IEC104_Slave_Close(sp_slave, NULL) == IEC104_TCP_OK);
|
||
sp_drain();
|
||
CHECK(IEC104_Spontaneous_Destroy(sp_publisher));
|
||
for (i = 0U; i < 2U; ++i) {
|
||
if (IEC104_Station_Is_Registered(&sp_stations[i])) {
|
||
CHECK(IEC104_Slave_Remove_Station(sp_slave, &sp_stations[i]) == IEC104_STATION_OK);
|
||
}
|
||
CHECK(IEC104_Station_Is_Reusable(&sp_stations[i]));
|
||
}
|
||
CHECK(IEC104_Slave_Destroy(sp_slave, NULL) == IEC104_TCP_OK);
|
||
sp_slave = NULL;
|
||
sp_publisher = NULL;
|
||
sut = NULL;
|
||
}
|
||
|
||
/**
|
||
* 功能:返回有效的最小单点变化模板。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:已填充站点、对象值及时间字段的变化记录。
|
||
* 说明:station_id绑定注册实例,CA用于编码和一致性检查。
|
||
* 显式PLAIN供通用编码与队列用例使用;验证项目默认CP56的用例须将forms恢复为0。
|
||
* 每例复制后只改所需字段,避免无关非法字段掩盖目标校验分支。
|
||
*/
|
||
static IEC104_SpontaneousChange_t sp_change(void)
|
||
{
|
||
IEC104_SpontaneousChange_t change;
|
||
memset(&change, 0, sizeof(change));
|
||
change.common_address = 0x1234U;
|
||
change.station_id = IEC104_Station_Get_Id(&sp_stations[0]);
|
||
change.ioa = 0x030201U;
|
||
change.kind = IEC104_SPONTANEOUS_SINGLE;
|
||
change.value.single = 1U;
|
||
change.forms = IEC104_SPONTANEOUS_FORM_PLAIN;
|
||
return change;
|
||
}
|
||
|
||
/**
|
||
* 功能:单步推进传输并读空通知。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:此处不制造采样值,也不自动确认任何I帧。
|
||
*/
|
||
static void sp_poll(void)
|
||
{
|
||
CHECK(IEC104_Slave_Poll(sp_slave, 0U, NULL) == IEC104_TCP_OK);
|
||
sp_drain();
|
||
}
|
||
|
||
/**
|
||
* 功能:建连并完成STARTDT,有限次Poll让已排队事件开始写出。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:ACK仍由用例显式注入。
|
||
*/
|
||
static void sp_connect(void)
|
||
{
|
||
unsigned i;
|
||
fake.accept_pending = 1U;
|
||
sp_poll();
|
||
push(start_act, sizeof(start_act));
|
||
for (i = 0U; i < 8U; ++i) { sp_poll(); }
|
||
CHECK(sut->connection.link_state.dt_state == IEC104_DT_STARTED);
|
||
}
|
||
|
||
/**
|
||
* 功能:从真实fake Net输出中按I帧顺序借出ASDU视图,跳过U/S帧。
|
||
* 输入参数:wanted——目标 I 帧序号;asdu_length——ASDU 长度存储。
|
||
* 输出参数:asdu_length——本次数据、文件或 ASDU 的实际长度。
|
||
* 返回值:借用模拟网络输出的目标 ASDU 起点;输出缓冲改变后不可继续使用。
|
||
* 说明:与sp_frames的“入NORMAL快照”区分,用于证明写出、重连重发和ACK生命周期。
|
||
*/
|
||
static const uint8_t *sp_wire_frame(unsigned wanted, size_t *asdu_length)
|
||
{
|
||
size_t offset = 0U;
|
||
unsigned found = 0U;
|
||
while (offset < fake.sent_bytes) {
|
||
const uint8_t *frame = fake.output + offset;
|
||
size_t length;
|
||
CHECK(fake.sent_bytes - offset >= 6U && frame[0] == 0x68U);
|
||
length = (size_t)frame[1] + 2U;
|
||
CHECK(length <= fake.sent_bytes - offset);
|
||
if ((frame[2] & 1U) == 0U) {
|
||
if (found++ == wanted) { *asdu_length = length - 6U; return frame + 6U; }
|
||
}
|
||
offset += length;
|
||
}
|
||
return NULL;
|
||
}
|
||
|
||
/**
|
||
* 功能:提交给定变化对象数组并核对完整变化项的发布计数。
|
||
* 输入参数:changes——待发布的变化对象数组(只读);count——对象、条目或站点数量。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:published按完整变化项计数;双报一项可能形成两个对象/帧,不能用asdus代替它。
|
||
* 此快捷入口只适用于预期整个输入都提交成功的用例。
|
||
*/
|
||
static void sp_publish_all(const IEC104_SpontaneousChange_t *changes, size_t count)
|
||
{
|
||
IEC104_SpontaneousPublishInfo_t info;
|
||
CHECK(IEC104_Spontaneous_Publish(sp_publisher, changes, count, &info) == IEC104_SPONTANEOUS_PUBLISH_OK);
|
||
CHECK(info.error == IEC104_SPONTANEOUS_ERROR_NONE && info.published == count && info.failed_index == SIZE_MAX);
|
||
}
|
||
|
||
/**
|
||
* 功能:直接查询真实队列状态,绕过只在被测实现内生效的宏钩子,不消耗注入序号。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:按值返回的当前状态或信息快照。
|
||
* 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。
|
||
*/
|
||
static IEC104_TcpServerStatus_t sp_transport_status(void)
|
||
{
|
||
IEC104_TcpServerStatus_t status;
|
||
CHECK(IEC104_Slave_Get_Status(sp_slave, &status, NULL) == IEC104_TCP_OK);
|
||
return status;
|
||
}
|
||
|
||
/**
|
||
* 功能:注入EOF并等待服务回到监听。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:不Close,保留NORMAL原文以验证未ACK事件的重连重发。
|
||
*/
|
||
static void sp_disconnect(void)
|
||
{
|
||
unsigned i;
|
||
IEC104_TcpServerStatus_t status;
|
||
fake.recv_eof = 1U;
|
||
for (i = 0U; i < 64U; ++i) {
|
||
sp_poll();
|
||
status = sp_transport_status();
|
||
if (!status.connected) { break; }
|
||
}
|
||
fake.recv_eof = 0U;
|
||
CHECK(i < 64U && !status.connected && status.listening);
|
||
}
|
||
|
||
/**
|
||
* 功能:绕过突发模块直接入NORMAL,模拟同服务其他生产者,用于区分队列总变化与本次发布统计。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。
|
||
*/
|
||
static void sp_external_enqueue(void)
|
||
{
|
||
IEC60870_Asdu_t raw;
|
||
uint8_t bytes[] = {1,1,3,0,0x34,0x12,1,2,3,1};
|
||
CHECK(IEC60870_Asdu_Create_From_Buffer(&raw, IEC104_Slave_Get_Application_Layer_Parameters(sp_slave),
|
||
bytes, sizeof(bytes)) == IEC60870_ASDU_OK);
|
||
CHECK(IEC104_Slave_Enqueue_Event(sp_slave, &raw) == IEC104_TCP_SUBMIT_OK);
|
||
}
|
||
|
||
/* ============================================================================
|
||
* [SPONTANEOUS/VALIDATION] 输入校验及辅助:前置条件、品质、配置与实例池
|
||
* ============================================================================ */
|
||
/**
|
||
* 功能:把非法项放在有效前缀之后,检查整批输入预检先于任何入队。
|
||
* 输入参数:invalid——故意构造的非法变化对象。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:failed_index=1且published=0,连前一项也不得发送;它与提交中途失败的部分成功不同。
|
||
*/
|
||
static void sp_expect_input(IEC104_SpontaneousChange_t invalid)
|
||
{
|
||
IEC104_SpontaneousChange_t changes[3];
|
||
IEC104_SpontaneousPublishInfo_t info;
|
||
IEC104_TcpServerStatus_t before, after;
|
||
unsigned enqueue_count = sp_enqueue_count, frame_count = sp_frame_count;
|
||
changes[0] = sp_change();
|
||
changes[0].common_address = 2U;
|
||
changes[0].station_id = IEC104_Station_Get_Id(&sp_stations[1]);
|
||
changes[1] = invalid;
|
||
changes[2] = changes[0];
|
||
CHECK(IEC104_Slave_Get_Status(sp_slave, &before, NULL) == IEC104_TCP_OK);
|
||
memset(&info, 0xa5, sizeof(info));
|
||
CHECK(IEC104_Spontaneous_Publish(sp_publisher, changes, 3U, &info) == IEC104_SPONTANEOUS_PUBLISH_ERROR);
|
||
CHECK(info.error == IEC104_SPONTANEOUS_ERROR_INPUT && info.failed_index == 1U && info.published == 0U);
|
||
CHECK(IEC104_Slave_Get_Status(sp_slave, &after, NULL) == IEC104_TCP_OK);
|
||
CHECK(after.normal_queue.stored_asdu_count == before.normal_queue.stored_asdu_count);
|
||
CHECK(after.normal_queue.pending_asdu_count == before.normal_queue.pending_asdu_count);
|
||
CHECK(after.normal_queue.used_bytes == before.normal_queue.used_bytes && fake.sent_bytes == 0U);
|
||
CHECK(sp_enqueue_count == enqueue_count && sp_frame_count == frame_count);
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:区分句柄/服务状态错误、输入错误与队列查询故障。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:空批次不依赖服务已Init。
|
||
* 失败时不得入队,计数须落到对应类别,不能把查询失败后的零快照当作服务已关闭。
|
||
*/
|
||
static void test_spontaneous_preconditions(void)
|
||
{
|
||
IEC104_SpontaneousPublishInfo_t info;
|
||
IEC104_SpontaneousStatus_t status;
|
||
IEC104_SpontaneousChange_t change;
|
||
unsigned queries;
|
||
sp_open(false, NULL);
|
||
change = sp_change();
|
||
CHECK(IEC104_Spontaneous_Publish(sp_publisher, &change, 1U, NULL) == IEC104_SPONTANEOUS_PUBLISH_ERROR);
|
||
CHECK(IEC104_Spontaneous_Publish(NULL, &change, 1U, &info) == IEC104_SPONTANEOUS_PUBLISH_ERROR);
|
||
CHECK(info.error == IEC104_SPONTANEOUS_ERROR_STATE && info.failed_index == SIZE_MAX && info.published == 0U);
|
||
queries = sp_query_count;
|
||
CHECK(IEC104_Spontaneous_Publish(sp_publisher, NULL, 0U, &info) == IEC104_SPONTANEOUS_PUBLISH_OK);
|
||
CHECK(info.error == IEC104_SPONTANEOUS_ERROR_NONE && info.published == 0U && info.failed_index == SIZE_MAX);
|
||
CHECK(sp_query_count == queries);
|
||
CHECK(IEC104_Spontaneous_Publish(sp_publisher, NULL, 1U, &info) == IEC104_SPONTANEOUS_PUBLISH_ERROR);
|
||
CHECK(info.error == IEC104_SPONTANEOUS_ERROR_INPUT && info.failed_index == SIZE_MAX);
|
||
CHECK(IEC104_Spontaneous_Publish(sp_publisher, &change, 1U, &info) == IEC104_SPONTANEOUS_PUBLISH_ERROR);
|
||
CHECK(info.error == IEC104_SPONTANEOUS_ERROR_STATE && info.published == 0U);
|
||
sp_initialize();
|
||
sp_query_failure = IEC104_TCP_INVALID_HANDLE;
|
||
sp_query_fail_at = sp_query_count + 1U;
|
||
CHECK(IEC104_Spontaneous_Publish(sp_publisher, &change, 1U, &info) == IEC104_SPONTANEOUS_PUBLISH_ERROR);
|
||
CHECK(info.error == IEC104_SPONTANEOUS_ERROR_STATE && info.published == 0U);
|
||
sp_query_failure = IEC104_TCP_INTERNAL_ERROR;
|
||
sp_query_fail_at = sp_query_count + 1U;
|
||
CHECK(IEC104_Spontaneous_Publish(sp_publisher, &change, 1U, &info) == IEC104_SPONTANEOUS_PUBLISH_ERROR);
|
||
CHECK(info.error == IEC104_SPONTANEOUS_ERROR_QUEUE && info.published == 0U);
|
||
sp_query_invalid_at = sp_query_count + 1U;
|
||
CHECK(IEC104_Spontaneous_Publish(sp_publisher, &change, 1U, &info) == IEC104_SPONTANEOUS_PUBLISH_ERROR);
|
||
CHECK(info.error == IEC104_SPONTANEOUS_ERROR_QUEUE && info.failed_index == SIZE_MAX);
|
||
CHECK(IEC104_Slave_Close(sp_slave, NULL) == IEC104_TCP_OK);
|
||
sp_drain();
|
||
queries = sp_query_count;
|
||
CHECK(IEC104_Spontaneous_Publish(sp_publisher, NULL, 0U, &info) == IEC104_SPONTANEOUS_PUBLISH_OK);
|
||
CHECK(sp_query_count == queries);
|
||
CHECK(IEC104_Spontaneous_Publish(sp_publisher, &change, 1U, &info) == IEC104_SPONTANEOUS_PUBLISH_ERROR);
|
||
CHECK(info.error == IEC104_SPONTANEOUS_ERROR_STATE && info.published == 0U);
|
||
CHECK(IEC104_Spontaneous_Get_Status(sp_publisher, &status));
|
||
CHECK(status.input_errors == 2U && status.state_errors == 3U && status.service_errors == 2U);
|
||
CHECK(status.asdus == 0U && status.published == 0U && status.objects == 0U);
|
||
sp_close();
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:把地址、类型、形态、值、品质和时间来源逐项置为非法,检查整批预检原子性。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:删除后重注册相同CA仍是新身份,旧station_id不得误授权给新节点。
|
||
*/
|
||
static void test_spontaneous_validation(void)
|
||
{
|
||
IEC104_SpontaneousChange_t change;
|
||
IEC104_SpontaneousStatus_t status;
|
||
unsigned i;
|
||
uint64_t old_id;
|
||
sp_open(true, NULL);
|
||
for (i = 0U; i < 26U; ++i) {
|
||
change = sp_change();
|
||
switch (i) {
|
||
case 0U: change.common_address = 0U; break;
|
||
case 1U: change.common_address = UINT16_MAX; break;
|
||
case 2U: change.common_address = 3U; break;
|
||
case 3U: change.station_id = UINT64_MAX; break;
|
||
case 4U: change.ioa = 0U; break;
|
||
case 5U: change.ioa = 0x1000000U; break;
|
||
case 6U: change.kind = (IEC104_SpontaneousKind_t)0; break;
|
||
case 7U: change.kind = (IEC104_SpontaneousKind_t)(IEC104_SPONTANEOUS_KIND_COUNT + 1U); break;
|
||
case 8U: change.cause = 1U; break;
|
||
case 9U: change.cause = 11U; break;
|
||
case 10U: change.cause = 0x83U; break;
|
||
case 11U: change.forms = 4U; break;
|
||
case 12U: change.forms = UINT8_MAX; break;
|
||
case 13U: change.value.single = 2U; break;
|
||
case 14U: change.kind = IEC104_SPONTANEOUS_DOUBLE; change.value.double_point = 4U; break;
|
||
case 15U: change.kind = IEC104_SPONTANEOUS_STEP; change.value.step.value = -65; break;
|
||
case 16U: change.kind = IEC104_SPONTANEOUS_STEP; change.value.step.value = 64; break;
|
||
case 17U: change.kind = IEC104_SPONTANEOUS_FLOAT; change.value.short_float = NAN; break;
|
||
case 18U: change.kind = IEC104_SPONTANEOUS_FLOAT; change.value.short_float = INFINITY; break;
|
||
case 19U: change.kind = IEC104_SPONTANEOUS_FLOAT; change.value.short_float = -INFINITY; break;
|
||
case 20U: change.quality = 1U; break;
|
||
case 21U: change.quality = 2U; break;
|
||
case 22U: change.kind = IEC104_SPONTANEOUS_DOUBLE; change.quality = 1U; break;
|
||
case 23U: change.kind = IEC104_SPONTANEOUS_DOUBLE; change.quality = 2U; break;
|
||
case 24U: change.time_kind = (IEC104_SpontaneousTimeKind_t)-1; break;
|
||
default: change.time_kind = (IEC104_SpontaneousTimeKind_t)3; break;
|
||
}
|
||
sp_expect_input(change);
|
||
}
|
||
for (i = 0U; i < 7U; ++i) {
|
||
change = sp_change();
|
||
change.kind = (IEC104_SpontaneousKind_t)(i + 1U);
|
||
change.quality = 0x0eU;
|
||
sp_expect_input(change);
|
||
}
|
||
change = sp_change();
|
||
old_id = change.station_id;
|
||
CHECK(IEC104_Slave_Remove_Station(sp_slave, &sp_stations[0]) == IEC104_STATION_OK);
|
||
sp_expect_input(change);
|
||
CHECK(IEC104_Station_Is_Reusable(&sp_stations[0]));
|
||
CHECK(IEC104_Slave_Add_Station(sp_slave, &sp_stations[0], 0x1234U, NULL) == IEC104_STATION_OK);
|
||
CHECK(IEC104_Station_Get_Id(&sp_stations[0]) != old_id);
|
||
sp_expect_input(change);
|
||
CHECK(IEC104_Spontaneous_Get_Status(sp_publisher, &status));
|
||
CHECK(status.input_errors == 35U && status.published == 0U && status.asdus == 0U);
|
||
CHECK(status.time_invalid == 0U && status.objects == 0U);
|
||
sp_close();
|
||
}
|
||
|
||
/**
|
||
* 功能:检查默认形态、非法配置、每Slave唯一实例和静态池上限。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:初始统计必须为零。
|
||
* Destroy后原句柄失效,再次Destroy/查询不得成功,也不能遗留Slave槽位。
|
||
*/
|
||
static void test_spontaneous_configuration_and_pool(void)
|
||
{
|
||
IEC104_SpontaneousConfig_t config, invalid;
|
||
IEC104_SpontaneousStatus_t status;
|
||
IEC104_Slave_t *slaves[IEC104_TCP_SERVER_CAPACITY];
|
||
IEC104_Spontaneous_t *publishers[IEC104_TCP_SERVER_CAPACITY];
|
||
unsigned i, kind;
|
||
|
||
memset(&fake, 0, sizeof(fake));
|
||
fake.now = 1000U;
|
||
test_spontaneous_config(NULL);
|
||
test_spontaneous_config(&config);
|
||
CHECK(config.originator_address == 0U && config.time_base_max_age_ms == 0U);
|
||
for (kind = 0U; kind < IEC104_SPONTANEOUS_KIND_COUNT; ++kind) {
|
||
CHECK(config.forms[kind] == (kind < 2U || (kind >= 10U && kind <= 12U) ? 2U : 1U));
|
||
}
|
||
CHECK(IEC104_Spontaneous_Create(NULL, &config) == NULL);
|
||
CHECK(!IEC104_Spontaneous_Destroy(NULL));
|
||
CHECK(!IEC104_Spontaneous_Get_Status(NULL, &status));
|
||
CHECK(!IEC104_Spontaneous_Set_Time_Base(NULL, 0U, 0U, false));
|
||
IEC104_Spontaneous_Clear_Time_Base(NULL);
|
||
IEC104_Spontaneous_Clear_Overflow(NULL);
|
||
|
||
for (i = 0U; i < IEC104_TCP_SERVER_CAPACITY; ++i) {
|
||
slaves[i] = IEC104_Slave_Create();
|
||
CHECK(slaves[i] != NULL);
|
||
CHECK(IEC104_Spontaneous_Create(slaves[i], NULL) == NULL);
|
||
for (kind = 0U; kind < IEC104_SPONTANEOUS_KIND_COUNT; ++kind) {
|
||
invalid = config;
|
||
invalid.forms[kind] = 0U;
|
||
CHECK(IEC104_Spontaneous_Create(slaves[i], &invalid) == NULL);
|
||
invalid.forms[kind] = 4U;
|
||
CHECK(IEC104_Spontaneous_Create(slaves[i], &invalid) == NULL);
|
||
invalid.forms[kind] = UINT8_MAX;
|
||
CHECK(IEC104_Spontaneous_Create(slaves[i], &invalid) == NULL);
|
||
}
|
||
publishers[i] = IEC104_Spontaneous_Create(slaves[i], &config);
|
||
CHECK(publishers[i] != NULL);
|
||
CHECK(IEC104_Spontaneous_Create(slaves[i], &config) == NULL);
|
||
CHECK(!IEC104_Spontaneous_Get_Status(publishers[i], NULL));
|
||
CHECK(IEC104_Spontaneous_Get_Status(publishers[i], &status));
|
||
CHECK(!status.time_base_valid && !status.time_synchronized && !status.overflow);
|
||
CHECK(status.published == 0U && status.asdus == 0U && status.objects == 0U);
|
||
CHECK(status.time_invalid == 0U && status.waits == 0U);
|
||
CHECK(status.input_errors == 0U && status.state_errors == 0U && status.service_errors == 0U);
|
||
CHECK(status.dropped_pending_asdus == 0U && status.overwritten_submitted_asdus == 0U);
|
||
CHECK(status.accounting_errors == 0U && status.clock_errors == 0U);
|
||
}
|
||
CHECK(IEC104_Slave_Create() == NULL);
|
||
for (i = 0U; i < IEC104_TCP_SERVER_CAPACITY; ++i) {
|
||
CHECK(IEC104_Spontaneous_Destroy(publishers[i]));
|
||
CHECK(!IEC104_Spontaneous_Destroy(publishers[i]));
|
||
CHECK(!IEC104_Spontaneous_Get_Status(publishers[i], &status));
|
||
CHECK(IEC104_Slave_Destroy(slaves[i], NULL) == IEC104_TCP_OK);
|
||
}
|
||
}
|
||
|
||
/* ============================================================================
|
||
* [SPONTANEOUS/TIME] 时间用例及辅助:UTC、单调时间、一致快照与WAIT重试
|
||
* ============================================================================ */
|
||
/**
|
||
* 功能:以独立7字节CP56预期校验单对象尾部,同时核对time_invalid按变化项累计。
|
||
* 输入参数:change——待检查的变化对象(只读);expected——期望的结果或数量(只读)。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:时间编码失败与值品质IV分开,不能仅比较值品质就认为时标有效。
|
||
*/
|
||
static void sp_expect_time(const IEC104_SpontaneousChange_t *change, const uint8_t expected[7])
|
||
{
|
||
IEC104_SpontaneousStatus_t before, after;
|
||
CHECK(IEC104_Spontaneous_Get_Status(sp_publisher, &before));
|
||
sp_frame_count = 0U;
|
||
sp_publish_all(change, 1U);
|
||
CHECK(sp_frame_count == 1U && sp_frames[0].length >= 17U);
|
||
if (memcmp(sp_frames[0].bytes + sp_frames[0].length - 7U, expected, 7U) != 0) {
|
||
unsigned i;
|
||
fprintf(stderr, "Time mismatch: mode=%u input=%llu now=%llu actual=", (unsigned)change->time_kind,
|
||
(unsigned long long)change->time_ms, (unsigned long long)fake.now);
|
||
for (i = 0U; i < 7U; ++i) { fprintf(stderr, "%02x ", sp_frames[0].bytes[sp_frames[0].length - 7U + i]); }
|
||
fprintf(stderr, " expected=");
|
||
for (i = 0U; i < 7U; ++i) { fprintf(stderr, "%02x ", expected[i]); }
|
||
fprintf(stderr, "\n");
|
||
}
|
||
CHECK(memcmp(sp_frames[0].bytes + sp_frames[0].length - 7U, expected, 7U) == 0);
|
||
CHECK(IEC104_Spontaneous_Get_Status(sp_publisher, &after));
|
||
CHECK(after.time_invalid - before.time_invalid == ((expected[2] & 0x80U) != 0U ? 1U : 0U));
|
||
CHECK(after.objects - before.objects == 1U && after.asdus - before.asdus == 1U);
|
||
}
|
||
|
||
/* 输入UTC毫秒按项目固定UTC+8编码,覆盖跨年、闰日和CP56年份范围边界。
|
||
* 越界用无效占位时标;显式UTC的有效性不依赖发布器当前是否已同步。 */
|
||
/**
|
||
* 功能:验证以下场景与约束:用手写CP56覆盖UTC边界、跨年和闰日。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:越界日期落到带IV的启动占位时间。
|
||
* 显式UTC的时标有效性与墙钟同步状态、对象SIQ品质分别核对。
|
||
*/
|
||
static void test_spontaneous_utc_times(void)
|
||
{
|
||
static const struct { uint64_t utc; bool invalid; uint8_t bytes[7]; } cases[] = {
|
||
{1704067200123ULL, false, {0x7b,0,0,8,0x21,1,24}},
|
||
{1704067200123ULL, true, {0x7b,0,0x80,8,0x21,1,24}},
|
||
{946656000000ULL, false, {0,0,0,0,0xc1,1,0}},
|
||
{946655999999ULL, false, {0,0,0x80,0,0xc1,1,0}},
|
||
{4102415999999ULL, false, {0x5f,0xea,59,23,0x9f,12,99}},
|
||
{4102416000000ULL, false, {0,0,0x80,0,0xc1,1,0}},
|
||
{UINT64_MAX, false, {0,0,0x80,0,0xc1,1,0}},
|
||
{0U, false, {0,0,0x80,0,0xc1,1,0}},
|
||
{1735660799999ULL, false, {0x5f,0xea,59,23,0x5f,12,24}},
|
||
{1735660800000ULL, false, {0,0,0,0,0x61,1,25}},
|
||
{1709164800000ULL, false, {0,0,0,8,0x9d,2,24}}
|
||
};
|
||
IEC104_SpontaneousChange_t change;
|
||
unsigned i;
|
||
sp_open(true, NULL);
|
||
change = sp_change();
|
||
change.forms = IEC104_SPONTANEOUS_FORM_CP56;
|
||
change.time_kind = IEC104_SPONTANEOUS_TIME_UTC;
|
||
for (i = 0U; i < sizeof(cases) / sizeof(cases[0]); ++i) {
|
||
change.time_ms = cases[i].utc;
|
||
change.time_invalid = cases[i].invalid;
|
||
sp_expect_time(&change, cases[i].bytes);
|
||
}
|
||
/* UTC quality is independent both of base synchronization and SIQ IV. */
|
||
CHECK(IEC104_Spontaneous_Set_Time_Base(sp_publisher, 0U, fake.now, false));
|
||
change.time_ms = cases[0].utc;
|
||
change.time_invalid = false;
|
||
change.quality = 0x80U;
|
||
sp_expect_time(&change, cases[0].bytes);
|
||
CHECK(sp_frames[0].bytes[9] == 0x81U);
|
||
change.quality = 0U;
|
||
change.time_invalid = true;
|
||
sp_expect_time(&change, cases[1].bytes);
|
||
CHECK(sp_frames[0].bytes[9] == 1U);
|
||
/* Every CP56 monitoring object gets the same independently known time. */
|
||
change.time_invalid = false;
|
||
for (i = 1U; i <= 7U; ++i) {
|
||
change.kind = (IEC104_SpontaneousKind_t)i;
|
||
memset(&change.value, 0, sizeof(change.value));
|
||
sp_expect_time(&change, cases[0].bytes);
|
||
}
|
||
sp_close();
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:MONOTONIC按采样时刻与基准的有符号差换算。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:AT_PUBLISH使用本次采样时刻。
|
||
* 覆盖未来采样、基准老化、倒退、无基准及加减溢出,确保无效时间不会绕回合法日期。
|
||
*/
|
||
static void test_spontaneous_monotonic_times(void)
|
||
{
|
||
static const uint8_t forward[] = {0x7b,0,0,8,0x21,1,24};
|
||
static const uint8_t backward[] = {0xe5,0xe9,59,7,0x21,1,24};
|
||
static const uint8_t at_publish[] = {0xe8,3,0,8,0x21,1,24};
|
||
static const uint8_t future[] = {0xe8,3,0x80,8,0x21,1,24};
|
||
static const uint8_t unsynchronized[] = {0x7b,0,0x80,8,0x21,1,24};
|
||
static const uint8_t placeholder[] = {0,0,0x80,0,0xc1,1,0};
|
||
const uint64_t maximum = (uint64_t)IEC60870_TIME_MAX_SECONDS * 1000U + 999U;
|
||
IEC104_SpontaneousConfig_t config;
|
||
IEC104_SpontaneousChange_t change, changes[2];
|
||
IEC104_SpontaneousStatus_t status;
|
||
unsigned long clock_errors;
|
||
test_spontaneous_config(&config);
|
||
config.time_base_max_age_ms = 1000U;
|
||
sp_open(true, &config);
|
||
fake.now = 5000U;
|
||
change = sp_change();
|
||
change.forms = IEC104_SPONTANEOUS_FORM_CP56;
|
||
change.time_kind = IEC104_SPONTANEOUS_TIME_MONOTONIC;
|
||
change.time_ms = 4123U;
|
||
CHECK(IEC104_Spontaneous_Set_Time_Base(sp_publisher, 1704067200000ULL, 4000U, true));
|
||
sp_expect_time(&change, forward);
|
||
change.time_ms = 3877U;
|
||
sp_expect_time(&change, backward);
|
||
change.time_ms = 6000U;
|
||
sp_expect_time(&change, future);
|
||
change.time_kind = IEC104_SPONTANEOUS_TIME_AT_PUBLISH;
|
||
change.time_ms = UINT64_MAX;
|
||
sp_expect_time(&change, at_publish);
|
||
change.time_kind = IEC104_SPONTANEOUS_TIME_MONOTONIC;
|
||
change.time_ms = 4123U;
|
||
CHECK(IEC104_Spontaneous_Get_Status(sp_publisher, &status) && status.time_synchronized);
|
||
fake.now = 5001U;
|
||
sp_expect_time(&change, unsynchronized);
|
||
CHECK(IEC104_Spontaneous_Get_Status(sp_publisher, &status) && !status.time_synchronized);
|
||
CHECK(IEC104_Spontaneous_Set_Time_Base(sp_publisher, 1704067200000ULL, 4000U, false));
|
||
fake.now = 5000U;
|
||
sp_expect_time(&change, unsynchronized);
|
||
CHECK(IEC104_Spontaneous_Set_Time_Base(sp_publisher, 1704067200000ULL, 4000U, true));
|
||
fake.now = 3999U;
|
||
CHECK(IEC104_Spontaneous_Get_Status(sp_publisher, &status));
|
||
clock_errors = status.clock_errors;
|
||
changes[0] = changes[1] = change;
|
||
changes[1].ioa++;
|
||
sp_frame_count = 0U;
|
||
sp_publish_all(changes, 2U);
|
||
CHECK(sp_frame_count == 2U && sp_frames[0].bytes[1] == 1U && sp_frames[1].bytes[1] == 1U);
|
||
CHECK(memcmp(sp_frames[0].bytes + 10U, placeholder, 7U) == 0);
|
||
CHECK(memcmp(sp_frames[1].bytes + 10U, placeholder, 7U) == 0);
|
||
CHECK(IEC104_Spontaneous_Get_Status(sp_publisher, &status));
|
||
CHECK(status.clock_errors == clock_errors + 1U && !status.time_synchronized);
|
||
CHECK(IEC104_Spontaneous_Get_Status(sp_publisher, &status) && status.clock_errors == clock_errors + 1U);
|
||
IEC104_Spontaneous_Clear_Time_Base(sp_publisher);
|
||
sp_expect_time(&change, placeholder);
|
||
change.time_kind = IEC104_SPONTANEOUS_TIME_AT_PUBLISH;
|
||
sp_expect_time(&change, placeholder);
|
||
fake.now = 5000U;
|
||
change.time_kind = IEC104_SPONTANEOUS_TIME_MONOTONIC;
|
||
change.time_ms = 3999U;
|
||
CHECK(IEC104_Spontaneous_Set_Time_Base(sp_publisher, 0U, 4000U, true));
|
||
sp_expect_time(&change, placeholder); /* subtraction underflow */
|
||
change.time_ms = 4001U;
|
||
CHECK(IEC104_Spontaneous_Set_Time_Base(sp_publisher, maximum, 4000U, true));
|
||
sp_expect_time(&change, placeholder); /* addition exceeds UTC maximum */
|
||
fake.now = UINT64_MAX;
|
||
CHECK(IEC104_Spontaneous_Set_Time_Base(sp_publisher, 1704067200000ULL, UINT64_MAX - 5U, true));
|
||
change.time_ms = 10U;
|
||
sp_expect_time(&change, placeholder); /* huge backwards delta cannot wrap */
|
||
sp_close();
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:同次Publish只读一次时钟,使批内对象时间一致。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:双报中途WAIT后重试会重新采样:
|
||
* AT_PUBLISH变为重试时刻;显式MONOTONIC采样值保持,但按重试时的新UTC基准换算。
|
||
*/
|
||
static void test_spontaneous_time_snapshot_and_retry(void)
|
||
{
|
||
static const uint8_t initial[] = {0,0,0,8,0x21,1,24};
|
||
static const uint8_t later[] = {0xe8,3,0,8,0x21,1,24};
|
||
IEC104_SpontaneousChange_t changes[3];
|
||
IEC104_SpontaneousPublishInfo_t info;
|
||
unsigned i;
|
||
sp_open(true, NULL);
|
||
CHECK(IEC104_Spontaneous_Set_Time_Base(sp_publisher, 1704067200000ULL, 1000U, true));
|
||
for (i = 0U; i < 3U; ++i) {
|
||
changes[i] = sp_change(); changes[i].ioa = i + 1U;
|
||
changes[i].forms = IEC104_SPONTANEOUS_FORM_CP56;
|
||
}
|
||
sp_now_reads = 0U;
|
||
sp_now_step = 1U;
|
||
sp_publish_all(changes, 3U);
|
||
CHECK(sp_now_reads == 1U);
|
||
sp_now_step = 0U;
|
||
CHECK(sp_frame_count == 3U);
|
||
for (i = 0U; i < 3U; ++i) {
|
||
CHECK(sp_frames[i].bytes[1] == 1U && memcmp(sp_frames[i].bytes + 10U, initial, 7U) == 0);
|
||
}
|
||
changes[0].forms = 3U;
|
||
sp_enqueue_fail_at = sp_enqueue_count + 2U;
|
||
CHECK(IEC104_Spontaneous_Publish(sp_publisher, changes, 1U, &info) == IEC104_SPONTANEOUS_PUBLISH_WAIT);
|
||
CHECK(info.published == 0U);
|
||
fake.now = 2000U;
|
||
sp_enqueue_fail_at = 0U;
|
||
sp_frame_count = 0U;
|
||
sp_publish_all(changes, 1U);
|
||
CHECK(sp_frame_count == 2U && memcmp(sp_frames[1].bytes + 10U, later, 7U) == 0);
|
||
sp_close();
|
||
|
||
sp_open(true, NULL);
|
||
CHECK(IEC104_Spontaneous_Set_Time_Base(sp_publisher, 1704067200000ULL, 1000U, true));
|
||
changes[0] = sp_change(); changes[0].forms = 3U;
|
||
changes[0].time_kind = IEC104_SPONTANEOUS_TIME_MONOTONIC;
|
||
changes[0].time_ms = 1000U;
|
||
sp_enqueue_fail_at = 2U;
|
||
CHECK(IEC104_Spontaneous_Publish(sp_publisher, changes, 1U, &info) == IEC104_SPONTANEOUS_PUBLISH_WAIT);
|
||
fake.now = 2000U;
|
||
CHECK(IEC104_Spontaneous_Set_Time_Base(sp_publisher, 1704067202000ULL, 2000U, true));
|
||
sp_enqueue_fail_at = 0U;
|
||
sp_frame_count = 0U;
|
||
sp_publish_all(changes, 1U);
|
||
CHECK(changes[0].time_ms == 1000U && memcmp(sp_frames[1].bytes + 10U, later, 7U) == 0);
|
||
sp_close();
|
||
}
|
||
|
||
/* ============================================================================
|
||
* [SPONTANEOUS/TIME_BASE] 时间基准生命周期:同步状态、老化和清除
|
||
* ============================================================================ */
|
||
/**
|
||
* 功能:验证以下场景与约束:配置按值复制。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:非法Set_Time_Base不能覆盖已有有效基准。老化阈值100毫秒在
|
||
* 恰等于时仍有效,超过后失去同步;只读Get_Status不累计clock_errors。
|
||
*/
|
||
static void test_spontaneous_time_base_lifecycle(void)
|
||
{
|
||
const uint64_t maximum = (uint64_t)IEC60870_TIME_MAX_SECONDS * 1000U + 999U;
|
||
IEC104_SpontaneousConfig_t config;
|
||
IEC104_SpontaneousStatus_t status;
|
||
IEC104_Slave_t *slave;
|
||
IEC104_Spontaneous_t *publisher;
|
||
|
||
memset(&fake, 0, sizeof(fake));
|
||
fake.now = 1000U;
|
||
slave = IEC104_Slave_Create();
|
||
CHECK(slave != NULL);
|
||
test_spontaneous_config(&config);
|
||
config.time_base_max_age_ms = 100U;
|
||
publisher = IEC104_Spontaneous_Create(slave, &config);
|
||
CHECK(publisher != NULL);
|
||
/* Changing caller storage must not change the copied age configuration. */
|
||
config.time_base_max_age_ms = 0U;
|
||
CHECK(!IEC104_Spontaneous_Set_Time_Base(publisher, 0U, 1001U, true));
|
||
CHECK(!IEC104_Spontaneous_Set_Time_Base(publisher, maximum + 1U, 1000U, true));
|
||
CHECK(IEC104_Spontaneous_Get_Status(publisher, &status) && !status.time_base_valid);
|
||
CHECK(IEC104_Spontaneous_Set_Time_Base(publisher, maximum, 1000U, false));
|
||
CHECK(IEC104_Spontaneous_Get_Status(publisher, &status));
|
||
CHECK(status.time_base_valid && !status.time_synchronized);
|
||
CHECK(IEC104_Spontaneous_Set_Time_Base(publisher, 1704067200000ULL, 1000U, true));
|
||
CHECK(!IEC104_Spontaneous_Set_Time_Base(publisher, maximum + 1U, 1000U, false));
|
||
CHECK(!IEC104_Spontaneous_Set_Time_Base(publisher, 0U, 1001U, false));
|
||
CHECK(IEC104_Spontaneous_Get_Status(publisher, &status) && status.time_synchronized);
|
||
fake.now = 1100U;
|
||
CHECK(IEC104_Spontaneous_Get_Status(publisher, &status) && status.time_synchronized);
|
||
fake.now = 1101U;
|
||
CHECK(IEC104_Spontaneous_Get_Status(publisher, &status) && !status.time_synchronized);
|
||
fake.now = 999U;
|
||
CHECK(IEC104_Spontaneous_Get_Status(publisher, &status) && !status.time_synchronized);
|
||
CHECK(status.clock_errors == 0U);
|
||
IEC104_Spontaneous_Clear_Overflow(publisher);
|
||
IEC104_Spontaneous_Clear_Time_Base(publisher);
|
||
CHECK(IEC104_Spontaneous_Get_Status(publisher, &status));
|
||
CHECK(!status.time_base_valid && !status.time_synchronized && status.clock_errors == 0U);
|
||
CHECK(IEC104_Spontaneous_Destroy(publisher));
|
||
CHECK(IEC104_Slave_Destroy(slave, NULL) == IEC104_TCP_OK);
|
||
}
|
||
|
||
/* ============================================================================
|
||
* [SPONTANEOUS/BASE_ENCODING] 基础监视类型:编码、帧上限、分段、重复IOA与部分提交
|
||
* ============================================================================ */
|
||
/**
|
||
* 功能:验证以下场景与约束:七种基础监视值分别走无时标/CP56形态,先比入队原文,再比真实发送输出。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:预期字节独立手写;没有时间基准时只把CP56置无效,值及品质保持调用方输入。
|
||
*/
|
||
static void test_spontaneous_encoding(void)
|
||
{
|
||
/* Independent, handwritten IEC bytes. CP56 is the invalid startup
|
||
* placeholder: Saturday 2000-01-01 00:00:00.000, standard time. */
|
||
static const uint8_t plain[7][14] = {
|
||
{1, 1, 3, 0x56, 0x34, 0x12, 1, 2, 3, 0x91},
|
||
{3, 1, 3, 0x56, 0x34, 0x12, 1, 2, 3, 0x92},
|
||
{5, 1, 3, 0x56, 0x34, 0x12, 1, 2, 3, 0xf4, 0x91},
|
||
{7, 1, 3, 0x56, 0x34, 0x12, 1, 2, 3, 0x12, 0x34, 0x56, 0x78, 0x91},
|
||
{9, 1, 3, 0x56, 0x34, 0x12, 1, 2, 3, 0xc7, 0xcf, 0x91},
|
||
{11, 1, 3, 0x56, 0x34, 0x12, 1, 2, 3, 0x34, 0x12, 0x91},
|
||
{13, 1, 3, 0x56, 0x34, 0x12, 1, 2, 3, 0, 0, 0xc0, 0x3f, 0x91}
|
||
};
|
||
static const uint8_t timed[7][21] = {
|
||
{30, 1, 12, 0x56, 0x34, 0x12, 1, 2, 3, 0x91, 0, 0, 0x80, 0, 0xc1, 1, 0},
|
||
{31, 1, 12, 0x56, 0x34, 0x12, 1, 2, 3, 0x92, 0, 0, 0x80, 0, 0xc1, 1, 0},
|
||
{32, 1, 12, 0x56, 0x34, 0x12, 1, 2, 3, 0xf4, 0x91, 0, 0, 0x80, 0, 0xc1, 1, 0},
|
||
{33, 1, 12, 0x56, 0x34, 0x12, 1, 2, 3, 0x12, 0x34, 0x56, 0x78, 0x91, 0, 0, 0x80, 0, 0xc1, 1, 0},
|
||
{34, 1, 12, 0x56, 0x34, 0x12, 1, 2, 3, 0xc7, 0xcf, 0x91, 0, 0, 0x80, 0, 0xc1, 1, 0},
|
||
{35, 1, 12, 0x56, 0x34, 0x12, 1, 2, 3, 0x34, 0x12, 0x91, 0, 0, 0x80, 0, 0xc1, 1, 0},
|
||
{36, 1, 12, 0x56, 0x34, 0x12, 1, 2, 3, 0, 0, 0xc0, 0x3f, 0x91, 0, 0, 0x80, 0, 0xc1, 1, 0}
|
||
};
|
||
static const uint8_t lengths[] = {10, 10, 11, 14, 12, 12, 14};
|
||
unsigned kind, form;
|
||
for (kind = 0U; kind < 7U; ++kind) {
|
||
for (form = 1U; form <= 2U; ++form) {
|
||
IEC104_SpontaneousChange_t change;
|
||
IEC104_SpontaneousStatus_t status;
|
||
const uint8_t *expected = form == 1U ? plain[kind] : timed[kind];
|
||
size_t length = lengths[kind] + (form == 2U ? 7U : 0U), wire_length;
|
||
const uint8_t *wire;
|
||
sp_open(true, NULL);
|
||
change = sp_change();
|
||
change.kind = (IEC104_SpontaneousKind_t)(kind + 1U);
|
||
change.forms = (uint8_t)form;
|
||
change.cause = (uint8_t)(form == 1U ? 3U : 12U);
|
||
change.quality = (uint8_t)(kind < 2U ? 0x90U : 0x91U);
|
||
switch (kind) {
|
||
case 0U: change.value.single = 1U; break;
|
||
case 1U: change.value.double_point = 2U; break;
|
||
case 2U: change.value.step.value = -12; change.value.step.transient = true; break;
|
||
case 3U: change.value.bitstring = 0x78563412U; break;
|
||
case 4U: change.value.normalized = -12345; break;
|
||
case 5U: change.value.scaled = 0x1234; break;
|
||
default: change.value.short_float = 1.5F; break;
|
||
}
|
||
sp_publish_all(&change, 1U);
|
||
CHECK(sp_frame_count == 1U && sp_frames[0].length == length);
|
||
CHECK(memcmp(sp_frames[0].bytes, expected, length) == 0);
|
||
CHECK(IEC104_Spontaneous_Get_Status(sp_publisher, &status));
|
||
CHECK(status.published == 1U && status.asdus == 1U && status.objects == 1U);
|
||
CHECK(status.time_invalid == (form == 2U ? 1U : 0U));
|
||
sp_connect();
|
||
wire = sp_wire_frame(0U, &wire_length);
|
||
CHECK(wire != NULL && wire_length == length && memcmp(wire, expected, length) == 0);
|
||
CHECK(sp_wire_frame(1U, &wire_length) == NULL);
|
||
sp_close();
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:默认单/双点变位与当地操作只发CP56。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:未校时通过时标IV表达,不退回无时标。
|
||
* forms=0继承项目默认,与显式CP56均逐对象进入SOE;当地操作继续走普通缓存。
|
||
*/
|
||
static void test_spontaneous_signal_default_forms(void)
|
||
{
|
||
/* 独立编码占位时刻:2000-01-01星期六零点、IV=1,避免复用被测时间编码器。 */
|
||
static const uint8_t invalid_time[] = {0, 0, 0x80, 0, 0xc1, 1, 0};
|
||
unsigned kind, i;
|
||
for (kind = 1U; kind <= 2U; ++kind) {
|
||
IEC104_SpontaneousChange_t changes[3];
|
||
IEC104_SpontaneousStatus_t status;
|
||
const uint8_t *wire;
|
||
size_t wire_length;
|
||
sp_open(true, NULL);
|
||
for (i = 0U; i < 3U; ++i) {
|
||
changes[i] = sp_change();
|
||
changes[i].kind = (IEC104_SpontaneousKind_t)kind;
|
||
changes[i].ioa = i + 1U;
|
||
changes[i].forms = 0U;
|
||
if (kind == 2U) { changes[i].value.double_point = 2U; }
|
||
}
|
||
changes[1].forms = IEC104_SPONTANEOUS_FORM_CP56;
|
||
changes[2].cause = IEC60870_ASDU_COT_RETURN_INFO_LOCAL;
|
||
sp_publish_all(changes, 3U);
|
||
CHECK(sp_frame_count == 3U);
|
||
for (i = 0U; i < 3U; ++i) {
|
||
CHECK(sp_frames[i].bytes[0] == kind + 29U && sp_frames[i].bytes[1] == 1U);
|
||
CHECK(sp_frames[i].bytes[2] == (i == 2U ? 12U : 3U) && sp_frames[i].length == 17U);
|
||
CHECK(sp_frames[i].bytes[9] == kind && memcmp(sp_frames[i].bytes + 10U, invalid_time, 7U) == 0);
|
||
}
|
||
CHECK(IEC104_Spontaneous_Get_Status(sp_publisher, &status));
|
||
CHECK(status.published == 3U && status.asdus == 3U && status.objects == 3U && status.time_invalid == 3U);
|
||
sp_connect();
|
||
for (i = 0U; i < 3U; ++i) {
|
||
wire = sp_wire_frame(i, &wire_length);
|
||
CHECK(wire != NULL && wire_length == sp_frames[i].length);
|
||
CHECK(memcmp(wire, sp_frames[i].bytes, wire_length) == 0);
|
||
}
|
||
CHECK(sp_wire_frame(3U, &wire_length) == NULL);
|
||
sp_close();
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:每种类型在单帧容量及容量+1处试单报/双报。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:核对帧数、对象步长和IOA连续覆盖。
|
||
* PLAIN和双报均由条目显式覆盖,保留通用兼容能力,不代表示例的默认上送策略。
|
||
* 双报以较小的CP56容量分批,保证同批两种形态包含相同的值与品质。
|
||
*/
|
||
static void test_spontaneous_frame_limits(void)
|
||
{
|
||
static const unsigned limits[7][2] = {{60,22}, {60,22}, {48,20}, {30,16}, {40,18}, {40,18}, {30,16}};
|
||
static const unsigned values[7] = {1,1,2,5,3,3,5};
|
||
static const unsigned types[7] = {1,3,5,7,9,11,13};
|
||
IEC104_SpontaneousChange_t changes[61];
|
||
unsigned kind, forms, extra, i;
|
||
for (kind = 0U; kind < 7U; ++kind) {
|
||
for (forms = 1U; forms <= 3U; ++forms) {
|
||
const unsigned limit = kind < 2U && forms == 2U ? 1U : limits[kind][forms == 1U ? 0U : 1U];
|
||
sp_open(true, NULL);
|
||
for (i = 0U; i <= limit; ++i) {
|
||
changes[i] = sp_change();
|
||
changes[i].kind = (IEC104_SpontaneousKind_t)(kind + 1U);
|
||
changes[i].ioa = i + 1U;
|
||
changes[i].forms = (uint8_t)forms;
|
||
memset(&changes[i].value, 0, sizeof(changes[i].value));
|
||
}
|
||
for (extra = 0U; extra <= 1U; ++extra) {
|
||
unsigned frame = 0U, begin_index = 0U;
|
||
sp_frame_count = 0U;
|
||
sp_publish_all(changes, limit + extra);
|
||
CHECK(sp_frame_count == (extra + 1U) * (forms == 3U ? 2U : 1U));
|
||
while (begin_index < limit + extra) {
|
||
unsigned objects = limit + extra - begin_index;
|
||
unsigned form;
|
||
if (objects > limit) { objects = limit; }
|
||
for (form = 1U; form <= 2U; ++form) {
|
||
unsigned stride = 3U + values[kind] + (form == 2U ? 7U : 0U);
|
||
const uint8_t *bytes;
|
||
if ((forms & form) == 0U) { continue; }
|
||
bytes = sp_frames[frame].bytes;
|
||
CHECK(bytes[0] == (form == 1U ? types[kind] : kind + 30U));
|
||
CHECK(bytes[1] == objects && bytes[2] == 3U && bytes[3] == 0x56U);
|
||
CHECK(sp_frames[frame].length == 6U + objects * stride);
|
||
for (i = 0U; i < objects; ++i) {
|
||
const uint8_t *object = bytes + 6U + i * stride;
|
||
CHECK(object[0] == begin_index + i + 1U && object[1] == 0U && object[2] == 0U);
|
||
if (form == 2U && forms == 3U) {
|
||
CHECK(memcmp(object, sp_frames[frame - 1U].bytes + 6U + i * (3U + values[kind]),
|
||
3U + values[kind]) == 0);
|
||
}
|
||
}
|
||
++frame;
|
||
}
|
||
begin_index += objects;
|
||
}
|
||
}
|
||
sp_close();
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:COT、CA、类型或上报形态改变都形成新的组批边界。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:同一批中重复IOA也须切段。
|
||
* 检查帧类型与对象数,保证同一点的多次变化按输入次序保留,不被隐式合并。
|
||
*/
|
||
static void test_spontaneous_segments_and_repeated_ioa(void)
|
||
{
|
||
static const uint8_t expected_types[] = {1,30,1,30,1,1,3,1,30};
|
||
IEC104_SpontaneousConfig_t config;
|
||
IEC104_SpontaneousChange_t changes[7];
|
||
unsigned i;
|
||
test_spontaneous_config(&config);
|
||
config.originator_address = 0x56U;
|
||
config.forms[IEC104_SPONTANEOUS_SINGLE - 1U] =
|
||
IEC104_SPONTANEOUS_FORM_PLAIN | IEC104_SPONTANEOUS_FORM_CP56;
|
||
sp_open(true, &config);
|
||
for (i = 0U; i < 7U; ++i) { changes[i] = sp_change(); changes[i].ioa = i + 1U; changes[i].forms = 3U; }
|
||
changes[0].forms = 0U;
|
||
changes[0].station_id = 0U;
|
||
changes[1].cause = 3U;
|
||
changes[2].cause = 12U;
|
||
changes[3].cause = 12U; changes[3].forms = 1U;
|
||
changes[4] = changes[3]; changes[4].common_address = 2U; changes[4].station_id = IEC104_Station_Get_Id(&sp_stations[1]);
|
||
changes[5] = changes[4]; changes[5].kind = IEC104_SPONTANEOUS_DOUBLE;
|
||
sp_publish_all(changes, 7U);
|
||
CHECK(sp_frame_count == sizeof(expected_types));
|
||
for (i = 0U; i < sp_frame_count; ++i) { CHECK(sp_frames[i].bytes[0] == expected_types[i]); }
|
||
CHECK(sp_frames[0].bytes[1] == 2U && sp_frames[1].bytes[1] == 2U);
|
||
CHECK(sp_frames[2].bytes[2] == 12U && sp_frames[5].bytes[4] == 2U && sp_frames[5].bytes[5] == 0U);
|
||
sp_frame_count = 0U;
|
||
for (i = 0U; i < 5U; ++i) {
|
||
changes[i] = sp_change(); changes[i].forms = 3U;
|
||
changes[i].ioa = i % 2U == 0U ? 1U : i + 1U;
|
||
changes[i].value.single = (uint8_t)(i % 2U);
|
||
}
|
||
sp_publish_all(changes, 5U);
|
||
CHECK(sp_frame_count == 6U);
|
||
for (i = 0U; i < 6U; ++i) { CHECK(sp_frames[i].bytes[1] == (i < 4U ? 2U : 1U)); }
|
||
sp_close();
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:同类型不同来源必须拆帧。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:默认与显式同级可合帧,双报继承等级,非法等级须在整批入队前拒绝。
|
||
*/
|
||
static void test_spontaneous_business_priority(void)
|
||
{
|
||
IEC104_SpontaneousChange_t changes[4], invalid;
|
||
unsigned i;
|
||
sp_open(true, NULL);
|
||
for (i = 0U; i < 4U; ++i) { changes[i] = sp_change(); changes[i].ioa = i + 1U; }
|
||
changes[1].priority = IEC104_BUSINESS_PRIORITY_SEQUENCE_EVENT;
|
||
changes[2].priority = IEC104_BUSINESS_PRIORITY_FAULT_EVENT;
|
||
changes[3].priority = IEC104_BUSINESS_PRIORITY_MEASUREMENT;
|
||
sp_publish_all(changes, 4U);
|
||
CHECK(sp_frame_count == 3U && sp_frames[0].bytes[1] == 2U);
|
||
CHECK(sp_frames[0].priority == IEC104_BUSINESS_PRIORITY_SEQUENCE_EVENT);
|
||
CHECK(sp_frames[1].priority == IEC104_BUSINESS_PRIORITY_FAULT_EVENT);
|
||
CHECK(sp_frames[2].priority == IEC104_BUSINESS_PRIORITY_MEASUREMENT);
|
||
changes[0] = sp_change(); changes[0].kind = IEC104_SPONTANEOUS_FLOAT;
|
||
changes[0].value.short_float = 1.5f; changes[0].forms = 3U;
|
||
sp_publish_all(changes, 1U);
|
||
CHECK(sp_frames[3].priority == IEC104_BUSINESS_PRIORITY_MEASUREMENT &&
|
||
sp_frames[4].priority == IEC104_BUSINESS_PRIORITY_MEASUREMENT);
|
||
changes[0] = sp_change(); changes[0].kind = IEC104_SPONTANEOUS_PROTECTION_EVENT;
|
||
changes[0].forms = IEC104_SPONTANEOUS_FORM_CP56;
|
||
sp_publish_all(changes, 1U);
|
||
CHECK(sp_frames[5].priority == IEC104_BUSINESS_PRIORITY_FAULT_EVENT);
|
||
invalid = sp_change(); invalid.priority = IEC104_BUSINESS_PRIORITY_COMMAND; sp_expect_input(invalid);
|
||
invalid.priority = UINT8_MAX; sp_expect_input(invalid);
|
||
sp_close();
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:每项同时要求无时标和CP56,在第1..4次入队处分别注入WAIT/ERROR/FATAL。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:published只覆盖两种形态都提交完的前缀;未完成项的第一种形态可能已提交,
|
||
* WAIT重试必须从该项开始并保留原值,因此允许重复第一帧,不能跳过该项。
|
||
*/
|
||
static void test_spontaneous_partial_submit(void)
|
||
{
|
||
static const IEC104_TcpSubmitResult_t failures[] = {IEC104_TCP_SUBMIT_WAIT, IEC104_TCP_SUBMIT_ERROR, IEC104_TCP_SUBMIT_FATAL};
|
||
unsigned fault, at;
|
||
for (fault = 0U; fault < 3U; ++fault) {
|
||
for (at = 1U; at <= 4U; ++at) {
|
||
IEC104_SpontaneousChange_t changes[3];
|
||
IEC104_SpontaneousPublishInfo_t info;
|
||
IEC104_SpontaneousStatus_t status;
|
||
unsigned i, prefix = (at - 1U) / 2U;
|
||
sp_open(true, NULL);
|
||
for (i = 0U; i < 3U; ++i) {
|
||
changes[i] = sp_change(); changes[i].forms = 3U; changes[i].value.single = (uint8_t)(i % 2U);
|
||
}
|
||
sp_enqueue_fail_at = at;
|
||
sp_enqueue_failure = failures[fault];
|
||
CHECK(IEC104_Spontaneous_Publish(sp_publisher, changes, 3U, &info) ==
|
||
(fault == 0U ? IEC104_SPONTANEOUS_PUBLISH_WAIT : IEC104_SPONTANEOUS_PUBLISH_ERROR));
|
||
CHECK(info.published == prefix && info.failed_index == SIZE_MAX);
|
||
CHECK(info.error == (fault == 0U ? IEC104_SPONTANEOUS_ERROR_NONE : IEC104_SPONTANEOUS_ERROR_SUBMIT));
|
||
if (fault != 0U) { CHECK(info.submit_result == failures[fault]); }
|
||
CHECK(sp_frame_count == at - 1U);
|
||
CHECK(IEC104_Spontaneous_Get_Status(sp_publisher, &status));
|
||
CHECK(status.published == prefix && status.asdus == at - 1U && status.objects == at - 1U);
|
||
CHECK(status.time_invalid == prefix && status.waits == (fault == 0U ? 1U : 0U));
|
||
CHECK(status.service_errors == (fault == 0U ? 0U : 1U));
|
||
if (fault == 0U) {
|
||
/* Correct caller policy: retry the unchanged suffix before a
|
||
* later value. An already accepted plain form may repeat. */
|
||
unsigned accepted = sp_frame_count;
|
||
sp_enqueue_fail_at = 0U;
|
||
sp_publish_all(changes + prefix, 3U - prefix);
|
||
for (i = prefix; i < 3U; ++i) {
|
||
CHECK(sp_frames[accepted + 2U * (i - prefix)].bytes[9] == i % 2U);
|
||
CHECK(sp_frames[accepted + 2U * (i - prefix) + 1U].bytes[9] == i % 2U);
|
||
}
|
||
changes[0].value.single = 1U;
|
||
sp_publish_all(changes, 1U);
|
||
CHECK(sp_frames[sp_frame_count - 1U].bytes[9] == 1U);
|
||
}
|
||
sp_close();
|
||
}
|
||
}
|
||
}
|
||
|
||
/* ============================================================================
|
||
* [SPONTANEOUS/EXTENDED] 扩展监视类型:累计量、成组单点、无品质值和保护事件
|
||
* ============================================================================ */
|
||
/**
|
||
* 功能:Additional monitoring families deliberately use handwritten wire oracles。
|
||
* 输入参数:kind——记录或对象类别。
|
||
* 输出参数:无。
|
||
* 返回值:已填充站点、对象值及时间字段的变化记录。
|
||
* 说明:no production type/size lookup is reused to calculate expected bytes.
|
||
*/
|
||
static IEC104_SpontaneousChange_t sp_extended_change(unsigned kind)
|
||
{
|
||
IEC104_SpontaneousChange_t change = sp_change();
|
||
memset(&change.value, 0, sizeof(change.value));
|
||
change.kind = (IEC104_SpontaneousKind_t)kind;
|
||
change.forms = 0U;
|
||
switch (kind) {
|
||
case IEC104_SPONTANEOUS_INTEGRATED_TOTALS:
|
||
change.value.integrated_totals.value = 0x12345678;
|
||
change.value.integrated_totals.sequence_number = 31U;
|
||
change.value.integrated_totals.has_carry = 1U;
|
||
change.value.integrated_totals.is_adjusted = 1U;
|
||
change.value.integrated_totals.is_invalid = 1U;
|
||
break;
|
||
case IEC104_SPONTANEOUS_PACKED_SINGLE:
|
||
change.value.packed_single.status = 0x1234U;
|
||
change.value.packed_single.change = 0xabcdU;
|
||
change.quality = 0x91U;
|
||
break;
|
||
case IEC104_SPONTANEOUS_NORMALIZED_NO_QUALITY:
|
||
change.value.normalized_no_quality = -12345;
|
||
break;
|
||
case IEC104_SPONTANEOUS_PROTECTION_EVENT:
|
||
change.value.protection.event = 2U;
|
||
change.value.protection.elapsed_time_ms = 0x1234U;
|
||
change.quality = 0x98U;
|
||
break;
|
||
case IEC104_SPONTANEOUS_PROTECTION_START:
|
||
change.value.protection.event = 0x25U;
|
||
change.value.protection.elapsed_time_ms = 0x1234U;
|
||
change.quality = 0x18U;
|
||
break;
|
||
case IEC104_SPONTANEOUS_INTEGRATED_TOTALS_SHORT:
|
||
change.value.short_float = 1.5f;
|
||
change.quality = 0x91U;
|
||
break;
|
||
default:
|
||
CHECK(kind == IEC104_SPONTANEOUS_PROTECTION_OUTPUT);
|
||
change.value.protection.event = 9U;
|
||
change.value.protection.elapsed_time_ms = 0x1234U;
|
||
change.quality = 0x90U;
|
||
break;
|
||
}
|
||
return change;
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:独立字节向量检查累计量、成组单点、无品质值及保护事件,含默认COT归一化。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:同时检查入队和线上ASDU,避免仅检查类型编号而漏掉BCR、SCD或经过时间布局。
|
||
*/
|
||
static void test_spontaneous_extended_encoding(void)
|
||
{
|
||
static const struct { uint8_t kind, form, length, bytes[21]; } cases[] = {
|
||
{8,1,14,{15,1,3,0x56,0x34,0x12,1,2,3,0x78,0x56,0x34,0x12,0xff}},
|
||
{8,2,21,{37,1,3,0x56,0x34,0x12,1,2,3,0x78,0x56,0x34,0x12,0xff,0,0,0x80,0,0xc1,1,0}},
|
||
{9,1,14,{20,1,3,0x56,0x34,0x12,1,2,3,0x34,0x12,0xcd,0xab,0x91}},
|
||
{10,1,11,{21,1,3,0x56,0x34,0x12,1,2,3,0xc7,0xcf}},
|
||
{11,2,19,{38,1,3,0x56,0x34,0x12,1,2,3,0x9a,0x34,0x12,0,0,0x80,0,0xc1,1,0}},
|
||
{12,2,20,{39,1,3,0x56,0x34,0x12,1,2,3,0x25,0x18,0x34,0x12,0,0,0x80,0,0xc1,1,0}},
|
||
{13,2,20,{40,1,3,0x56,0x34,0x12,1,2,3,9,0x90,0x34,0x12,0,0,0x80,0,0xc1,1,0}},
|
||
{14,1,14,{206,1,3,0x56,0x34,0x12,1,2,3,0,0,0xc0,0x3f,0x91}},
|
||
{14,2,21,{207,1,3,0x56,0x34,0x12,1,2,3,0,0,0xc0,0x3f,0x91,0,0,0x80,0,0xc1,1,0}}
|
||
};
|
||
unsigned i;
|
||
for (i = 0U; i < sizeof(cases) / sizeof(cases[0]); ++i) {
|
||
IEC104_SpontaneousChange_t change;
|
||
IEC104_SpontaneousStatus_t status;
|
||
size_t wire_length;
|
||
const uint8_t *wire;
|
||
sp_open(true, NULL);
|
||
change = sp_extended_change(cases[i].kind);
|
||
change.forms = cases[i].form;
|
||
change.cause = (uint8_t)(i % 2U == 0U ? 0U : 3U);
|
||
sp_publish_all(&change, 1U);
|
||
CHECK(sp_frame_count == 1U && sp_frames[0].length == cases[i].length);
|
||
CHECK(memcmp(sp_frames[0].bytes, cases[i].bytes, cases[i].length) == 0);
|
||
CHECK(IEC104_Spontaneous_Get_Status(sp_publisher, &status));
|
||
CHECK(status.published == 1U && status.objects == 1U && status.asdus == 1U);
|
||
CHECK(status.time_invalid == (cases[i].form == 2U ? 1U : 0U));
|
||
sp_connect();
|
||
wire = sp_wire_frame(0U, &wire_length);
|
||
CHECK(wire != NULL && wire_length == cases[i].length);
|
||
CHECK(memcmp(wire, cases[i].bytes, wire_length) == 0);
|
||
CHECK(sp_wire_frame(1U, &wire_length) == NULL);
|
||
sp_close();
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:对扩展类型逐一检查容量边界与下一帧首IOA。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:累计量双报保持15/37及206/207对象前缀一致。
|
||
* 249字节上限和对象数同时验证,覆盖不同载荷长度带来的分帧差异。
|
||
*/
|
||
static void test_spontaneous_extended_limits(void)
|
||
{
|
||
static const struct { uint8_t kind, forms, limit, value_size, plain, timed; } cases[] = {
|
||
{8,1,30,5,15,37}, {8,2,16,5,15,37}, {8,3,16,5,15,37},
|
||
{9,1,30,5,20,0}, {10,1,48,2,21,0},
|
||
{11,2,18,3,0,38}, {12,2,17,4,0,39}, {13,2,17,4,0,40},
|
||
{14,1,30,5,206,207}, {14,2,16,5,206,207}, {14,3,16,5,206,207}
|
||
};
|
||
IEC104_SpontaneousChange_t changes[49];
|
||
unsigned c, extra, i;
|
||
for (c = 0U; c < sizeof(cases) / sizeof(cases[0]); ++c) {
|
||
sp_open(true, NULL);
|
||
for (i = 0U; i <= cases[c].limit; ++i) {
|
||
changes[i] = sp_extended_change(cases[c].kind);
|
||
changes[i].ioa = i + 1U;
|
||
changes[i].forms = cases[c].forms;
|
||
}
|
||
for (extra = 0U; extra <= 1U; ++extra) {
|
||
unsigned frame = 0U, begin = 0U;
|
||
sp_frame_count = 0U;
|
||
sp_publish_all(changes, cases[c].limit + extra);
|
||
CHECK(sp_frame_count == (extra + 1U) * (cases[c].forms == 3U ? 2U : 1U));
|
||
while (begin < cases[c].limit + extra) {
|
||
unsigned count = cases[c].limit + extra - begin, form;
|
||
if (count > cases[c].limit) { count = cases[c].limit; }
|
||
for (form = 1U; form <= 2U; ++form) {
|
||
unsigned stride = 3U + cases[c].value_size + (form == 2U ? 7U : 0U);
|
||
const uint8_t *bytes;
|
||
if ((cases[c].forms & form) == 0U) { continue; }
|
||
bytes = sp_frames[frame].bytes;
|
||
CHECK(bytes[0] == (form == 1U ? cases[c].plain : cases[c].timed));
|
||
CHECK(bytes[1] == count && bytes[2] == 3U && bytes[3] == 0x56U);
|
||
CHECK(sp_frames[frame].length == 6U + count * stride);
|
||
CHECK(sp_frames[frame].length <= 249U);
|
||
for (i = 0U; i < count; ++i) {
|
||
const uint8_t *object = bytes + 6U + i * stride;
|
||
CHECK(object[0] == begin + i + 1U && object[1] == 0U && object[2] == 0U);
|
||
if (form == 2U && cases[c].forms == 3U) {
|
||
CHECK(memcmp(object, sp_frames[frame - 1U].bytes + 6U + i * 8U, 8U) == 0);
|
||
}
|
||
}
|
||
++frame;
|
||
}
|
||
begin += count;
|
||
}
|
||
}
|
||
sp_close();
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 功能:检查扩展类型允许的形态/COT及BCR、QDP、SCD等字段边界。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:非法项整批不提交。
|
||
* 再用计数值、事件位和经过时间的合法端点排除“过度拒绝”;BCR的IV不借用通用品质字段。
|
||
*/
|
||
static void test_spontaneous_extended_validation(void)
|
||
{
|
||
static const uint8_t causes[] = {1,2,11,12,37,0x83};
|
||
static const uint8_t default_types[] = {15,20,21,38,39,40};
|
||
IEC104_SpontaneousConfig_t config;
|
||
IEC104_SpontaneousChange_t change;
|
||
IEC104_SpontaneousStatus_t status;
|
||
IEC104_Slave_t *slave = IEC104_Slave_Create();
|
||
unsigned kind, form, i, invalid_count = 0U;
|
||
CHECK(slave != NULL);
|
||
for (kind = 8U; kind <= 13U; ++kind) {
|
||
for (form = 1U; form <= 3U; ++form) {
|
||
IEC104_Spontaneous_t *publisher;
|
||
bool supported = kind == 8U || (kind <= 10U ? form == 1U : form == 2U);
|
||
test_spontaneous_config(&config);
|
||
config.forms[kind - 1U] = (uint8_t)form;
|
||
publisher = IEC104_Spontaneous_Create(slave, &config);
|
||
CHECK((publisher != NULL) == supported);
|
||
if (publisher != NULL) { CHECK(IEC104_Spontaneous_Destroy(publisher)); }
|
||
}
|
||
}
|
||
CHECK(IEC104_Slave_Destroy(slave, NULL) == IEC104_TCP_OK);
|
||
sp_open(true, NULL);
|
||
for (kind = 8U; kind <= 13U; ++kind) {
|
||
change = sp_extended_change(kind);
|
||
sp_frame_count = 0U;
|
||
sp_publish_all(&change, 1U);
|
||
CHECK(sp_frame_count == 1U && sp_frames[0].bytes[0] == default_types[kind - 8U]);
|
||
CHECK(sp_frames[0].bytes[2] == 3U);
|
||
for (form = 1U; form <= 3U; ++form) {
|
||
change = sp_extended_change(kind);
|
||
change.forms = (uint8_t)form;
|
||
if (kind == 8U || (kind <= 10U ? form == 1U : form == 2U)) {
|
||
sp_publish_all(&change, 1U);
|
||
} else { sp_expect_input(change); ++invalid_count; }
|
||
}
|
||
for (i = 0U; i < sizeof(causes); ++i) {
|
||
change = sp_extended_change(kind);
|
||
change.cause = causes[i];
|
||
sp_expect_input(change); ++invalid_count;
|
||
}
|
||
change = sp_extended_change(kind);
|
||
change.quality = (uint8_t)(kind == 8U || kind == 10U ? 0x80U : (kind == 9U ? 2U : 4U));
|
||
sp_expect_input(change); ++invalid_count;
|
||
if (kind >= 11U) {
|
||
change = sp_extended_change(kind);
|
||
change.quality = 1U;
|
||
sp_expect_input(change); ++invalid_count;
|
||
change = sp_extended_change(kind);
|
||
change.value.protection.event = (uint8_t)(kind == 11U ? 4U : (kind == 12U ? 64U : 16U));
|
||
sp_expect_input(change); ++invalid_count;
|
||
}
|
||
}
|
||
for (i = 0U; i < 4U; ++i) {
|
||
change = sp_extended_change(8U);
|
||
switch (i) {
|
||
case 0U: change.value.integrated_totals.sequence_number = 32U; break;
|
||
case 1U: change.value.integrated_totals.has_carry = 2U; break;
|
||
case 2U: change.value.integrated_totals.is_adjusted = 2U; break;
|
||
default: change.value.integrated_totals.is_invalid = 2U; break;
|
||
}
|
||
sp_expect_input(change); ++invalid_count;
|
||
}
|
||
CHECK(invalid_count == 62U);
|
||
CHECK(IEC104_Spontaneous_Get_Status(sp_publisher, &status));
|
||
CHECK(status.input_errors == invalid_count);
|
||
/* Both signed counter extremes and all elapsed-time/event endpoints are
|
||
* valid. BCR IV is encoded inside the BCR, never in change.quality. */
|
||
for (i = 0U; i < 2U; ++i) {
|
||
change = sp_extended_change(8U);
|
||
change.value.integrated_totals.value = i == 0U ? INT32_MIN : INT32_MAX;
|
||
change.value.integrated_totals.sequence_number = (uint8_t)(i == 0U ? 0U : 31U);
|
||
change.value.integrated_totals.has_carry = (uint8_t)i;
|
||
change.value.integrated_totals.is_adjusted = (uint8_t)i;
|
||
change.value.integrated_totals.is_invalid = (uint8_t)i;
|
||
sp_frame_count = 0U;
|
||
sp_publish_all(&change, 1U);
|
||
CHECK(sp_frames[0].bytes[9] == (i == 0U ? 0U : 0xffU));
|
||
CHECK(sp_frames[0].bytes[12] == (i == 0U ? 0x80U : 0x7fU));
|
||
CHECK(sp_frames[0].bytes[13] == (i == 0U ? 0U : 0xffU));
|
||
for (kind = 11U; kind <= 13U; ++kind) {
|
||
unsigned elapsed_offset = kind == 11U ? 10U : 11U;
|
||
change = sp_extended_change(kind);
|
||
change.quality = 0xf8U;
|
||
change.value.protection.event = (uint8_t)(i == 0U ? 0U : (kind == 11U ? 3U : (kind == 12U ? 63U : 15U)));
|
||
change.value.protection.elapsed_time_ms = (uint16_t)(i == 0U ? 0U : UINT16_MAX);
|
||
sp_frame_count = 0U;
|
||
sp_publish_all(&change, 1U);
|
||
CHECK(sp_frames[0].bytes[9] == (uint8_t)(change.value.protection.event | (kind == 11U ? 0xf8U : 0U)));
|
||
CHECK(sp_frames[0].bytes[elapsed_offset] == (i == 0U ? 0U : 0xffU));
|
||
CHECK(sp_frames[0].bytes[elapsed_offset + 1U] == (i == 0U ? 0U : 0xffU));
|
||
}
|
||
}
|
||
sp_close();
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:扩展类型也必须保留同IOA连续变化,逐帧值递增可发现覆盖/合并错误。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:累计量双报交替15/37,其余类型按配置单报;随后验证不同类型之间不会混批。
|
||
*/
|
||
static void test_spontaneous_extended_repeated_ioa(void)
|
||
{
|
||
static const uint8_t types[] = {15,20,21,38,39,40};
|
||
IEC104_SpontaneousChange_t changes[6];
|
||
unsigned kind, i;
|
||
for (kind = 8U; kind <= 13U; ++kind) {
|
||
unsigned copies = kind == 8U ? 2U : 1U;
|
||
sp_open(true, NULL);
|
||
for (i = 0U; i < 3U; ++i) {
|
||
changes[i] = sp_extended_change(kind);
|
||
changes[i].quality = 0U;
|
||
if (kind == 8U) { changes[i].forms = 3U; changes[i].value.integrated_totals.value = (int32_t)i; }
|
||
else if (kind == 9U) { changes[i].value.packed_single.status = (uint16_t)i; }
|
||
else if (kind == 10U) { changes[i].value.normalized_no_quality = (int16_t)i; }
|
||
else { changes[i].value.protection.event = (uint8_t)i; }
|
||
}
|
||
sp_publish_all(changes, 3U);
|
||
CHECK(sp_frame_count == 3U * copies);
|
||
for (i = 0U; i < sp_frame_count; ++i) {
|
||
CHECK(sp_frames[i].bytes[0] == (copies == 2U && i % 2U != 0U ? 37U : types[kind - 8U]));
|
||
CHECK(sp_frames[i].bytes[1] == 1U && sp_frames[i].bytes[9] == i / copies);
|
||
}
|
||
sp_close();
|
||
}
|
||
sp_open(true, NULL);
|
||
for (i = 0U; i < 6U; ++i) { changes[i] = sp_extended_change(i + 8U); }
|
||
sp_publish_all(changes, 6U);
|
||
CHECK(sp_frame_count == 6U);
|
||
for (i = 0U; i < 6U; ++i) { CHECK(sp_frames[i].bytes[0] == types[i]); }
|
||
sp_close();
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:保护事件交叉组合CP56的IV、QDP的IV与经过时间无效EI,逐字段检查三者独立。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:无墙钟基准只影响时标,不能把数据品质或经过时间品质一起改写。
|
||
*/
|
||
static void test_spontaneous_protection_time_quality(void)
|
||
{
|
||
static const uint8_t times[2][7] = {
|
||
{0x7b,0,0,8,0x21,1,24}, {0,0,0x80,0,0xc1,1,0}
|
||
};
|
||
unsigned kind, invalid_time, invalid_quality, invalid_elapsed;
|
||
sp_open(true, NULL);
|
||
for (kind = 11U; kind <= 13U; ++kind) {
|
||
for (invalid_time = 0U; invalid_time <= 1U; ++invalid_time) {
|
||
for (invalid_quality = 0U; invalid_quality <= 1U; ++invalid_quality) {
|
||
for (invalid_elapsed = 0U; invalid_elapsed <= 1U; ++invalid_elapsed) {
|
||
IEC104_SpontaneousChange_t change = sp_extended_change(kind);
|
||
change.quality = (uint8_t)(0x10U | (invalid_elapsed != 0U ? 0x08U : 0U) |
|
||
(invalid_quality != 0U ? 0x80U : 0U));
|
||
if (invalid_time == 0U) {
|
||
change.time_kind = IEC104_SPONTANEOUS_TIME_UTC;
|
||
change.time_ms = 1704067200123ULL;
|
||
} else {
|
||
/* sp_open has no clock base, so AT_PUBLISH encodes the
|
||
* startup placeholder independently of EI and QDP IV. */
|
||
CHECK(change.time_kind == IEC104_SPONTANEOUS_TIME_AT_PUBLISH);
|
||
}
|
||
sp_expect_time(&change, times[invalid_time]);
|
||
CHECK((sp_frames[0].bytes[kind == 11U ? 9U : 10U] & 0xf8U) == change.quality);
|
||
CHECK(sp_frames[0].bytes[sp_frames[0].length - 5U] == (invalid_time != 0U ? 0x80U : 0U));
|
||
}
|
||
}
|
||
}
|
||
}
|
||
sp_close();
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:Type15已接手、Type37返回WAIT时整项仍未完成。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:重试会再次发送相同Type15。
|
||
* 此处提供固定UTC采样时刻,即使fake.now推进一分钟,重试的CP56也不能改成发送时间。
|
||
*/
|
||
static void test_spontaneous_totals_partial_submit(void)
|
||
{
|
||
IEC104_SpontaneousChange_t changes[2];
|
||
IEC104_SpontaneousPublishInfo_t info;
|
||
IEC104_SpontaneousStatus_t status;
|
||
unsigned i;
|
||
sp_open(true, NULL);
|
||
for (i = 0U; i < 2U; ++i) {
|
||
changes[i] = sp_extended_change(8U);
|
||
changes[i].forms = 3U;
|
||
changes[i].value.integrated_totals.value += (int32_t)i;
|
||
changes[i].time_kind = IEC104_SPONTANEOUS_TIME_UTC;
|
||
changes[i].time_ms = 1704067200123ULL;
|
||
}
|
||
sp_enqueue_fail_at = 2U;
|
||
CHECK(IEC104_Spontaneous_Publish(sp_publisher, changes, 2U, &info) == IEC104_SPONTANEOUS_PUBLISH_WAIT);
|
||
CHECK(info.published == 0U && info.failed_index == SIZE_MAX && info.error == IEC104_SPONTANEOUS_ERROR_NONE);
|
||
CHECK(sp_frame_count == 1U && sp_frames[0].bytes[0] == 15U);
|
||
CHECK(IEC104_Spontaneous_Get_Status(sp_publisher, &status));
|
||
CHECK(status.published == 0U && status.objects == 1U && status.asdus == 1U && status.waits == 1U);
|
||
sp_enqueue_fail_at = 0U;
|
||
fake.now += 60000U;
|
||
sp_publish_all(changes, 2U);
|
||
CHECK(sp_frame_count == 5U);
|
||
CHECK(sp_frames[0].length == sp_frames[1].length);
|
||
CHECK(memcmp(sp_frames[0].bytes, sp_frames[1].bytes, sp_frames[0].length) == 0);
|
||
for (i = 1U; i < 5U; ++i) {
|
||
CHECK(sp_frames[i].bytes[0] == (i % 2U != 0U ? 15U : 37U));
|
||
CHECK(sp_frames[i].bytes[9] == (i < 3U ? 0x78U : 0x79U));
|
||
if (i % 2U == 0U) {
|
||
static const uint8_t expected_time[] = {0x7b,0,0,8,0x21,1,24};
|
||
CHECK(memcmp(sp_frames[i].bytes + 14U, expected_time, sizeof(expected_time)) == 0);
|
||
}
|
||
}
|
||
CHECK(IEC104_Spontaneous_Get_Status(sp_publisher, &status));
|
||
CHECK(status.published == 2U && status.objects == 5U && status.asdus == 5U);
|
||
CHECK(status.waits == 1U && status.time_invalid == 0U);
|
||
sp_close();
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:浮点累计量默认无时标,各配置可被逐项形态覆盖。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:其COT固定为3。
|
||
* 非有限值或保留品质位使整批预检失败;合法QDS的IV不改变冻结时刻的IV。
|
||
*/
|
||
static void test_spontaneous_float_totals_validation(void)
|
||
{
|
||
static const uint8_t invalid_causes[] = {1,2,11,12,37,0x83};
|
||
static const uint8_t qualities[] = {0,1,0x10,0x20,0x40,0x80,0xf1};
|
||
static const float invalid_values[] = {NAN, INFINITY, -INFINITY};
|
||
static const float finite_values[] = {0.0f, -0.0f, FLT_MIN, -FLT_MIN, FLT_MAX, -FLT_MAX};
|
||
IEC104_SpontaneousConfig_t config;
|
||
IEC104_SpontaneousChange_t change;
|
||
unsigned configured, form, i, invalid;
|
||
for (configured = 1U; configured <= 3U; ++configured) {
|
||
test_spontaneous_config(&config);
|
||
CHECK(config.forms[IEC104_SPONTANEOUS_INTEGRATED_TOTALS_SHORT - 1U] == 1U);
|
||
config.forms[IEC104_SPONTANEOUS_INTEGRATED_TOTALS_SHORT - 1U] = (uint8_t)configured;
|
||
sp_open(true, &config);
|
||
for (form = 0U; form <= 3U; ++form) {
|
||
unsigned selected = form == 0U ? configured : form;
|
||
change = sp_extended_change(IEC104_SPONTANEOUS_INTEGRATED_TOTALS_SHORT);
|
||
change.forms = (uint8_t)form;
|
||
change.cause = (uint8_t)(form % 2U == 0U ? 0U : 3U);
|
||
sp_frame_count = 0U;
|
||
sp_publish_all(&change, 1U);
|
||
CHECK(sp_frame_count == (selected == 3U ? 2U : 1U));
|
||
CHECK(sp_frames[0].bytes[0] == (selected == 2U ? 207U : 206U));
|
||
CHECK(sp_frames[0].bytes[2] == 3U);
|
||
if (selected == 3U) {
|
||
CHECK(sp_frames[1].bytes[0] == 207U && sp_frames[1].bytes[2] == 3U);
|
||
CHECK(memcmp(sp_frames[0].bytes + 6U, sp_frames[1].bytes + 6U, 8U) == 0);
|
||
}
|
||
}
|
||
sp_close();
|
||
}
|
||
sp_open(true, NULL);
|
||
for (i = 0U; i < sizeof(invalid_causes); ++i) {
|
||
change = sp_extended_change(IEC104_SPONTANEOUS_INTEGRATED_TOTALS_SHORT);
|
||
change.cause = invalid_causes[i];
|
||
sp_expect_input(change);
|
||
}
|
||
for (i = 0U; i < sizeof(invalid_values) / sizeof(invalid_values[0]); ++i) {
|
||
change = sp_extended_change(IEC104_SPONTANEOUS_INTEGRATED_TOTALS_SHORT);
|
||
change.value.short_float = invalid_values[i];
|
||
sp_expect_input(change);
|
||
}
|
||
for (i = 2U; i <= 8U; i *= 2U) {
|
||
change = sp_extended_change(IEC104_SPONTANEOUS_INTEGRATED_TOTALS_SHORT);
|
||
change.quality = (uint8_t)i;
|
||
sp_expect_input(change);
|
||
}
|
||
for (i = 0U; i < sizeof(finite_values) / sizeof(finite_values[0]); ++i) {
|
||
change = sp_extended_change(IEC104_SPONTANEOUS_INTEGRATED_TOTALS_SHORT);
|
||
change.value.short_float = finite_values[i];
|
||
sp_publish_all(&change, 1U);
|
||
}
|
||
for (i = 0U; i < sizeof(qualities); ++i) {
|
||
for (invalid = 0U; invalid <= 1U; ++invalid) {
|
||
uint8_t expected_time[] = {0x7b,0,0,8,0x21,1,24};
|
||
change = sp_extended_change(IEC104_SPONTANEOUS_INTEGRATED_TOTALS_SHORT);
|
||
change.forms = IEC104_SPONTANEOUS_FORM_CP56;
|
||
change.quality = qualities[i];
|
||
change.time_kind = IEC104_SPONTANEOUS_TIME_UTC;
|
||
change.time_ms = 1704067200123ULL;
|
||
change.time_invalid = invalid != 0U;
|
||
expected_time[2] = (uint8_t)(invalid != 0U ? 0x80U : 0U);
|
||
sp_frame_count = 0U;
|
||
sp_publish_all(&change, 1U);
|
||
CHECK(sp_frame_count == 1U && sp_frames[0].length == 21U);
|
||
CHECK(sp_frames[0].bytes[0] == 207U && sp_frames[0].bytes[13] == qualities[i]);
|
||
CHECK(memcmp(sp_frames[0].bytes + 14U, expected_time, sizeof(expected_time)) == 0);
|
||
}
|
||
}
|
||
sp_close();
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:在两项同IOA冻结快照的每个提交位置注入WAIT:双报未完成的项不计published。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:只重试未完成后缀;UTC和MONOTONIC都保留采样时刻,且输入值、品质、时刻不被改写。
|
||
*/
|
||
static void test_spontaneous_float_totals_partial_submit(void)
|
||
{
|
||
static const uint8_t expected_values[2][4] = {{0,0,0xc0,0x3f}, {0,0,0x20,0x40}};
|
||
static const uint8_t expected_time[] = {0x7b,0,0,8,0x21,1,24};
|
||
unsigned mode, fail_at, i;
|
||
for (mode = 0U; mode < 2U; ++mode) {
|
||
for (fail_at = 1U; fail_at <= 4U; ++fail_at) {
|
||
IEC104_SpontaneousChange_t changes[2], before[2];
|
||
IEC104_SpontaneousPublishInfo_t info;
|
||
IEC104_SpontaneousStatus_t status;
|
||
size_t published;
|
||
sp_open(true, NULL);
|
||
fake.now = 5000U;
|
||
CHECK(IEC104_Spontaneous_Set_Time_Base(sp_publisher, 1704067200000ULL, 4000U, true));
|
||
for (i = 0U; i < 2U; ++i) {
|
||
changes[i] = sp_extended_change(IEC104_SPONTANEOUS_INTEGRATED_TOTALS_SHORT);
|
||
changes[i].forms = 3U;
|
||
changes[i].value.short_float = i == 0U ? 1.5f : 2.5f;
|
||
changes[i].quality = (uint8_t)(i == 0U ? 0x91U : 0x11U);
|
||
changes[i].time_kind = mode == 0U ? IEC104_SPONTANEOUS_TIME_UTC : IEC104_SPONTANEOUS_TIME_MONOTONIC;
|
||
changes[i].time_ms = mode == 0U ? 1704067200123ULL : 4123U;
|
||
}
|
||
memcpy(before, changes, sizeof(before));
|
||
sp_enqueue_fail_at = fail_at;
|
||
CHECK(IEC104_Spontaneous_Publish(sp_publisher, changes, 2U, &info) == IEC104_SPONTANEOUS_PUBLISH_WAIT);
|
||
published = info.published;
|
||
CHECK(published == (fail_at - 1U) / 2U);
|
||
CHECK(info.failed_index == SIZE_MAX && info.error == IEC104_SPONTANEOUS_ERROR_NONE);
|
||
CHECK(sp_frame_count == fail_at - 1U);
|
||
CHECK(memcmp(changes, before, sizeof(before)) == 0);
|
||
CHECK(IEC104_Spontaneous_Get_Status(sp_publisher, &status));
|
||
CHECK(status.published == published && status.objects == sp_frame_count && status.waits == 1U);
|
||
sp_enqueue_fail_at = 0U;
|
||
fake.now += 60000U;
|
||
sp_publish_all(changes + published, 2U - published);
|
||
CHECK(memcmp(changes, before, sizeof(before)) == 0);
|
||
CHECK(sp_frame_count == 4U + (fail_at % 2U == 0U ? 1U : 0U));
|
||
for (i = 0U; i < sp_frame_count; ++i) {
|
||
unsigned frame = i < fail_at - 1U ? i : i - (fail_at - 1U);
|
||
size_t point = i < fail_at - 1U ? i / 2U : published + frame / 2U;
|
||
bool timed = frame % 2U != 0U;
|
||
CHECK(sp_frames[i].bytes[0] == (timed ? 207U : 206U));
|
||
CHECK(sp_frames[i].length == (timed ? 21U : 14U));
|
||
CHECK(sp_frames[i].bytes[1] == 1U && sp_frames[i].bytes[2] == 3U);
|
||
CHECK(memcmp(sp_frames[i].bytes + 9U, expected_values[point], 4U) == 0);
|
||
CHECK(sp_frames[i].bytes[13] == (point == 0U ? 0x91U : 0x11U));
|
||
if (timed) {
|
||
CHECK(memcmp(sp_frames[i].bytes + 14U, expected_time, sizeof(expected_time)) == 0);
|
||
}
|
||
}
|
||
CHECK(IEC104_Spontaneous_Get_Status(sp_publisher, &status));
|
||
CHECK(status.published == 2U && status.objects == sp_frame_count && status.asdus == sp_frame_count);
|
||
CHECK(status.waits == 1U && status.time_invalid == 0U);
|
||
sp_close();
|
||
}
|
||
}
|
||
}
|
||
|
||
/* ============================================================================
|
||
* [SPONTANEOUS/OVERWRITE] 覆盖用例:待发/已提交原文、双报保留与计数失败
|
||
* ============================================================================ */
|
||
/**
|
||
* 功能:验证256条源SOE独立保留,普通事件过载不挤占,新增第257条只淘汰最早SOE。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:重复IOA的每次变位均占一个槽;连接后检查最早保留原文及原始CP56,覆盖统计仅增加一次。
|
||
*/
|
||
static void test_spontaneous_compact_capacity(void)
|
||
{
|
||
const unsigned other_slots = IEC104_TCP_NORMAL_CAPACITY / (IEC104_ASDU_NORMAL_ENTRY_HEADER_LEN + 10U);
|
||
IEC104_SpontaneousChange_t change;
|
||
IEC104_SpontaneousStatus_t status;
|
||
IEC104_TcpServerStatus_t queue;
|
||
const uint8_t *wire;
|
||
size_t wire_length;
|
||
unsigned i;
|
||
sp_open(true, NULL);
|
||
change = sp_change();
|
||
change.forms = IEC104_SPONTANEOUS_FORM_CP56;
|
||
change.time_kind = IEC104_SPONTANEOUS_TIME_UTC;
|
||
for (i = 0U; i < 256U; ++i) {
|
||
change.time_ms = 1704067200000ULL + i;
|
||
change.value.single = (uint8_t)(i % 2U);
|
||
sp_publish_all(&change, 1U);
|
||
}
|
||
queue = sp_transport_status();
|
||
CHECK(queue.soe_queue.capacity == 256U && queue.soe_queue.stored_count == 256U);
|
||
CHECK(queue.soe_queue.pending_count == 256U && queue.soe_queue.dropped_pending_count == 0U);
|
||
for (i = 0U; i < other_slots + 7U; ++i) { sp_external_enqueue(); }
|
||
queue = sp_transport_status();
|
||
CHECK(queue.soe_queue.stored_count == 256U && queue.soe_queue.dropped_pending_count == 0U);
|
||
CHECK(queue.normal_queue.stored_asdu_count == 256U + other_slots);
|
||
change.time_ms = 1704067200256ULL;
|
||
change.value.single = 0U;
|
||
sp_publish_all(&change, 1U);
|
||
queue = sp_transport_status();
|
||
CHECK(queue.soe_queue.stored_count == 256U && queue.soe_queue.dropped_pending_count == 1U);
|
||
CHECK(IEC104_Spontaneous_Get_Status(sp_publisher, &status));
|
||
CHECK(status.asdus == 257U && status.published == 257U && status.dropped_pending_asdus == 1U);
|
||
CHECK(status.overwritten_submitted_asdus == 0U && status.overflow && status.accounting_errors == 0U);
|
||
sp_connect();
|
||
wire = sp_wire_frame(0U, &wire_length);
|
||
CHECK(wire != NULL && wire_length == sp_frames[1].length);
|
||
CHECK(memcmp(wire, sp_frames[1].bytes, wire_length) == 0);
|
||
sp_close();
|
||
}
|
||
|
||
/**
|
||
* 功能:验证SOE占位冻结原文、阻挡较晚SOE,并在交付、取消、QRP2清除或覆盖后正确终结。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:较早正常SOE可先发送;占位放行不重新取时,取消不算覆盖,清除和淘汰后的票据不能复生。
|
||
*/
|
||
static void test_spontaneous_deferred_soe(void)
|
||
{
|
||
IEC104_SpontaneousChange_t change;
|
||
IEC104_SpontaneousPublishInfo_t info;
|
||
IEC104_SpontaneousStatus_t status;
|
||
IEC104_TcpServerStatus_t queue;
|
||
IEC104_SoeTicket_t ticket;
|
||
uint8_t frozen[17];
|
||
const uint8_t *wire;
|
||
size_t wire_length;
|
||
uint32_t removed;
|
||
unsigned i;
|
||
sp_open(true, NULL);
|
||
CHECK(IEC104_Spontaneous_Set_Time_Base(sp_publisher, 1704067200000ULL, fake.now, true));
|
||
change = sp_change(); change.forms = IEC104_SPONTANEOUS_FORM_CP56; change.ioa = 1U;
|
||
sp_publish_all(&change, 1U);
|
||
change.ioa = 2U;
|
||
CHECK(IEC104_Spontaneous_Defer_Soe(sp_publisher, &change, &ticket, &info) == IEC104_SPONTANEOUS_PUBLISH_OK);
|
||
CHECK(ticket.serial != 0U && info.published == 1U && info.error == IEC104_SPONTANEOUS_ERROR_NONE);
|
||
CHECK(sp_frames[1].length == sizeof(frozen));
|
||
memcpy(frozen, sp_frames[1].bytes, sizeof(frozen));
|
||
change.ioa = 3U;
|
||
sp_publish_all(&change, 1U);
|
||
queue = sp_transport_status();
|
||
CHECK(queue.soe_queue.pending_count == 2U && queue.soe_queue.deferred_count == 1U);
|
||
CHECK(queue.normal_queue.pending_asdu_count == 3U);
|
||
sp_connect();
|
||
wire = sp_wire_frame(0U, &wire_length);
|
||
CHECK(wire != NULL && wire[6] == 1U && sp_wire_frame(1U, &wire_length) == NULL);
|
||
fake.now += 60000U;
|
||
CHECK(IEC104_Spontaneous_Set_Time_Base(sp_publisher, 1800000000000ULL, fake.now, true));
|
||
CHECK(IEC104_Slave_Resolve_Soe(sp_slave, &ticket, true) == IEC104_TCP_OK);
|
||
for (i = 0U; i < 8U; ++i) { sp_poll(); }
|
||
wire = sp_wire_frame(1U, &wire_length);
|
||
CHECK(wire != NULL && wire_length == sizeof(frozen) && memcmp(wire, frozen, sizeof(frozen)) == 0);
|
||
wire = sp_wire_frame(2U, &wire_length);
|
||
CHECK(wire != NULL && wire[6] == 3U);
|
||
change.ioa = 4U;
|
||
CHECK(IEC104_Spontaneous_Defer_Soe(sp_publisher, &change, &ticket, &info) == IEC104_SPONTANEOUS_PUBLISH_OK);
|
||
change.ioa = 5U;
|
||
sp_publish_all(&change, 1U);
|
||
CHECK(IEC104_Slave_Resolve_Soe(sp_slave, &ticket, false) == IEC104_TCP_OK);
|
||
for (i = 0U; i < 8U; ++i) { sp_poll(); }
|
||
wire = sp_wire_frame(3U, &wire_length);
|
||
CHECK(wire != NULL && wire[6] == 5U && sp_wire_frame(4U, &wire_length) == NULL);
|
||
CHECK(IEC104_Spontaneous_Get_Status(sp_publisher, &status));
|
||
CHECK(!status.overflow && status.accounting_errors == 0U && status.dropped_pending_asdus == 0U);
|
||
sp_close();
|
||
|
||
sp_open(true, NULL);
|
||
change = sp_change(); change.forms = IEC104_SPONTANEOUS_FORM_CP56;
|
||
CHECK(IEC104_Spontaneous_Defer_Soe(sp_publisher, &change, &ticket, &info) == IEC104_SPONTANEOUS_PUBLISH_OK);
|
||
sp_publish_all(&change, 1U);
|
||
CHECK(IEC104_Slave_Discard_Pending_Events(sp_slave, change.common_address,
|
||
IEC104_SLAVE_EVENTS_TIME_TAGGED, &removed, NULL) == IEC104_TCP_OK && removed == 2U);
|
||
CHECK(IEC104_Slave_Resolve_Soe(sp_slave, &ticket, true) == IEC104_TCP_OK);
|
||
queue = sp_transport_status();
|
||
CHECK(queue.soe_queue.stored_count == 0U && queue.soe_queue.deferred_count == 0U);
|
||
CHECK(IEC104_Spontaneous_Defer_Soe(sp_publisher, &change, &ticket, &info) == IEC104_SPONTANEOUS_PUBLISH_OK);
|
||
for (i = 0U; i < 256U; ++i) { sp_publish_all(&change, 1U); }
|
||
CHECK(IEC104_Slave_Resolve_Soe(sp_slave, &ticket, true) == IEC104_TCP_OK);
|
||
queue = sp_transport_status();
|
||
CHECK(queue.soe_queue.stored_count == 256U && queue.soe_queue.deferred_count == 0U);
|
||
CHECK(queue.soe_queue.dropped_pending_count == 1U);
|
||
sp_close();
|
||
}
|
||
|
||
/**
|
||
* 功能:验证占位接口拒绝非SOE输入且失败不改票据,普通SOE逐对象失败仍给出精确交接前缀。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:PLAIN、双报、当地操作及遥测不能占用SOE;WAIT、ERROR、FATAL均不得重交已接手前缀。
|
||
*/
|
||
static void test_spontaneous_compact_validation_and_partial(void)
|
||
{
|
||
static const IEC104_TcpSubmitResult_t failures[] = {
|
||
IEC104_TCP_SUBMIT_WAIT, IEC104_TCP_SUBMIT_ERROR, IEC104_TCP_SUBMIT_FATAL
|
||
};
|
||
IEC104_SpontaneousChange_t changes[3];
|
||
IEC104_SpontaneousPublishInfo_t info;
|
||
IEC104_SoeTicket_t ticket, original;
|
||
unsigned variant, fault, i;
|
||
sp_open(true, NULL);
|
||
memset(&original, 0x5a, sizeof(original));
|
||
for (variant = 0U; variant < 5U; ++variant) {
|
||
changes[0] = sp_change(); changes[0].forms = IEC104_SPONTANEOUS_FORM_CP56;
|
||
if (variant == 0U) { changes[0].forms = IEC104_SPONTANEOUS_FORM_PLAIN; }
|
||
else if (variant == 1U) { changes[0].forms = 3U; }
|
||
else if (variant == 2U) { changes[0].cause = IEC60870_ASDU_COT_RETURN_INFO_LOCAL; }
|
||
else if (variant == 3U) { changes[0].kind = IEC104_SPONTANEOUS_SCALED; }
|
||
ticket = original;
|
||
CHECK(IEC104_Spontaneous_Defer_Soe(sp_publisher, changes, variant == 4U ? NULL : &ticket,
|
||
&info) == IEC104_SPONTANEOUS_PUBLISH_ERROR);
|
||
CHECK(info.error == IEC104_SPONTANEOUS_ERROR_INPUT && info.published == 0U);
|
||
CHECK(memcmp(&ticket, &original, sizeof(ticket)) == 0 && sp_frame_count == 0U);
|
||
}
|
||
changes[0] = sp_change(); changes[0].forms = IEC104_SPONTANEOUS_FORM_CP56;
|
||
ticket = original;
|
||
sp_enqueue_fail_at = 1U;
|
||
CHECK(IEC104_Spontaneous_Defer_Soe(sp_publisher, changes, &ticket, &info) == IEC104_SPONTANEOUS_PUBLISH_WAIT);
|
||
CHECK(info.published == 0U && memcmp(&ticket, &original, sizeof(ticket)) == 0 && sp_frame_count == 0U);
|
||
sp_close();
|
||
for (fault = 0U; fault < sizeof(failures) / sizeof(failures[0]); ++fault) {
|
||
sp_open(true, NULL);
|
||
for (i = 0U; i < 3U; ++i) {
|
||
changes[i] = sp_change(); changes[i].forms = IEC104_SPONTANEOUS_FORM_CP56; changes[i].ioa = i + 1U;
|
||
}
|
||
sp_enqueue_fail_at = 2U; sp_enqueue_failure = failures[fault];
|
||
CHECK(IEC104_Spontaneous_Publish(sp_publisher, changes, 3U, &info) ==
|
||
(fault == 0U ? IEC104_SPONTANEOUS_PUBLISH_WAIT : IEC104_SPONTANEOUS_PUBLISH_ERROR));
|
||
CHECK(info.published == 1U && sp_frame_count == 1U && sp_frames[0].bytes[6] == 1U);
|
||
CHECK(info.error == (fault == 0U ? IEC104_SPONTANEOUS_ERROR_NONE : IEC104_SPONTANEOUS_ERROR_SUBMIT));
|
||
sp_enqueue_fail_at = 0U;
|
||
sp_publish_all(changes + 1U, 2U);
|
||
CHECK(sp_frame_count == 3U && sp_frames[1].bytes[6] == 2U && sp_frames[2].bytes[6] == 3U);
|
||
sp_close();
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:用重复IOA强制每项单独成帧,超过NORMAL容量后核对队列保留的最新后缀及覆盖计数。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:本次Publish覆盖其他生产者原文也计入本次增量;发布之外的覆盖不会追溯计入本实例。
|
||
*/
|
||
static void test_spontaneous_pending_overwrite(void)
|
||
{
|
||
const unsigned slots = IEC104_TCP_NORMAL_CAPACITY / (IEC104_ASDU_NORMAL_ENTRY_HEADER_LEN + 10U);
|
||
IEC104_SpontaneousChange_t changes[IEC104_TCP_NORMAL_CAPACITY / (IEC104_ASDU_NORMAL_ENTRY_HEADER_LEN + 10U) + 5U];
|
||
IEC104_SpontaneousStatus_t status;
|
||
IEC104_TcpServerStatus_t queue;
|
||
IEC104_AsduHeadInfo_t entry;
|
||
uint8_t bytes[IEC104_MAX_ASDU_LEN];
|
||
unsigned i;
|
||
sp_open(true, NULL);
|
||
for (i = 0U; i < slots + 5U; ++i) {
|
||
changes[i] = sp_change(); changes[i].value.single = (uint8_t)(i % 2U);
|
||
}
|
||
/* Repeated IOA forces one ASDU per change. A single Publish overwrites
|
||
* its own earlier frames, but all changes were successfully handed off. */
|
||
sp_publish_all(changes, slots + 5U);
|
||
queue = sp_transport_status();
|
||
CHECK(queue.normal_queue.stored_asdu_count == slots && queue.normal_queue.pending_asdu_count == slots);
|
||
CHECK(IEC104_Spontaneous_Get_Status(sp_publisher, &status));
|
||
CHECK(status.published == slots + 5U && status.asdus == slots + 5U && status.objects == slots + 5U);
|
||
CHECK(status.dropped_pending_asdus == 5U && status.overwritten_submitted_asdus == 0U && status.overflow);
|
||
for (i = 0U; i < slots; ++i) {
|
||
CHECK(IEC104_AsduQueue_Get_Entry_By_Offset(&sut->queue, IEC104_ASDU_PRIORITY_NORMAL, i, &entry) == IEC104_ASDU_QUEUE_OK);
|
||
CHECK(IEC104_AsduQueue_Copy_Asdu(&entry, bytes, sizeof(bytes)) == IEC104_ASDU_QUEUE_OK);
|
||
CHECK(entry.asdu_length == 10U && bytes[9] == (i + 5U) % 2U);
|
||
}
|
||
IEC104_Spontaneous_Clear_Overflow(sp_publisher);
|
||
CHECK(IEC104_Spontaneous_Get_Status(sp_publisher, &status) && !status.overflow && status.dropped_pending_asdus == 5U);
|
||
sp_publish_all(changes, 1U);
|
||
CHECK(IEC104_Spontaneous_Get_Status(sp_publisher, &status) && status.overflow && status.dropped_pending_asdus == 6U);
|
||
sp_close();
|
||
|
||
/* Ownership of the overwritten original is deliberately irrelevant. */
|
||
sp_open(true, NULL);
|
||
for (i = 0U; i < slots; ++i) { sp_external_enqueue(); }
|
||
changes[0] = sp_change();
|
||
sp_publish_all(changes, 1U);
|
||
CHECK(IEC104_Spontaneous_Get_Status(sp_publisher, &status));
|
||
CHECK(status.asdus == 1U && status.dropped_pending_asdus == 1U && status.overflow);
|
||
IEC104_Spontaneous_Clear_Overflow(sp_publisher);
|
||
sp_external_enqueue();
|
||
CHECK(IEC104_Spontaneous_Get_Status(sp_publisher, &status));
|
||
CHECK(status.asdus == 1U && status.dropped_pending_asdus == 1U && !status.overflow);
|
||
sp_close();
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:区分“已发未ACK原文被覆盖”与“断线恢复为待发后被覆盖”:前者仍能按序ACK,
|
||
* 后者计入待发丢弃并置overflow。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:两类计数不能混用。
|
||
*/
|
||
static void test_spontaneous_submitted_and_restored_overwrite(void)
|
||
{
|
||
const unsigned slots = IEC104_TCP_NORMAL_CAPACITY / (IEC104_ASDU_NORMAL_ENTRY_HEADER_LEN + 10U);
|
||
IEC104_SpontaneousChange_t changes[IEC104_TCP_NORMAL_CAPACITY / (IEC104_ASDU_NORMAL_ENTRY_HEADER_LEN + 10U)];
|
||
IEC104_SpontaneousStatus_t status;
|
||
IEC104_TcpServerStatus_t queue;
|
||
unsigned i;
|
||
size_t wire_length;
|
||
sp_open(true, NULL);
|
||
for (i = 0U; i < slots; ++i) { changes[i] = sp_change(); }
|
||
sp_publish_all(changes, 1U);
|
||
sp_connect();
|
||
queue = sp_transport_status();
|
||
CHECK(queue.normal_queue.stored_asdu_count == 1U && queue.normal_queue.pending_asdu_count == 0U);
|
||
sp_publish_all(changes, slots - 1U);
|
||
CHECK(IEC104_Spontaneous_Get_Status(sp_publisher, &status) && !status.overflow);
|
||
sp_publish_all(changes, 1U);
|
||
CHECK(IEC104_Spontaneous_Get_Status(sp_publisher, &status));
|
||
CHECK(status.overwritten_submitted_asdus == 1U && status.dropped_pending_asdus == 0U && !status.overflow);
|
||
CHECK(sp_wire_frame(0U, &wire_length) != NULL && wire_length == 10U);
|
||
/* The overwritten original was already transmitted; ACK must still work. */
|
||
push_ack(1U);
|
||
sp_poll();
|
||
queue = sp_transport_status();
|
||
CHECK(queue.connected);
|
||
sp_close();
|
||
|
||
sp_open(true, NULL);
|
||
for (i = 0U; i < slots; ++i) { changes[i] = sp_change(); }
|
||
sp_publish_all(changes, 1U);
|
||
sp_connect();
|
||
CHECK(sp_wire_frame(0U, &wire_length) != NULL);
|
||
sp_disconnect();
|
||
queue = sp_transport_status();
|
||
CHECK(queue.normal_queue.pending_asdu_count == 1U && queue.normal_queue.stored_asdu_count == 1U);
|
||
sp_publish_all(changes, slots);
|
||
CHECK(IEC104_Spontaneous_Get_Status(sp_publisher, &status));
|
||
CHECK(status.dropped_pending_asdus == 1U && status.overwritten_submitted_asdus == 0U && status.overflow);
|
||
sp_close();
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:同一批22点先交无时标帧,再交CP56帧。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:小NORMAL配置中后者可以覆盖前者。
|
||
* Publish成功只表示两帧都曾被接手,不承诺双报原文始终同时保留在队列。
|
||
*/
|
||
static void test_spontaneous_dual_retention(void)
|
||
{
|
||
IEC104_SpontaneousChange_t changes[22];
|
||
IEC104_SpontaneousStatus_t status;
|
||
IEC104_TcpServerStatus_t queue;
|
||
IEC104_AsduHeadInfo_t entry;
|
||
uint8_t bytes[IEC104_MAX_ASDU_LEN];
|
||
unsigned i;
|
||
sp_open(true, NULL);
|
||
for (i = 0U; i < 22U; ++i) {
|
||
changes[i] = sp_change(); changes[i].ioa = i + 1U; changes[i].forms = 3U;
|
||
}
|
||
sp_publish_all(changes, 22U);
|
||
CHECK(IEC104_Spontaneous_Get_Status(sp_publisher, &status));
|
||
CHECK(status.published == 22U && status.asdus == 2U && status.objects == 44U && status.time_invalid == 22U);
|
||
queue = sp_transport_status();
|
||
if (IEC104_TCP_NORMAL_CAPACITY < 94U + 248U + 2U * IEC104_ASDU_NORMAL_ENTRY_HEADER_LEN) {
|
||
CHECK(queue.normal_queue.stored_asdu_count == 1U && status.dropped_pending_asdus == 1U && status.overflow);
|
||
CHECK(IEC104_AsduQueue_Peek_Head(&sut->queue, IEC104_ASDU_PRIORITY_NORMAL, &entry) == IEC104_ASDU_QUEUE_OK);
|
||
CHECK(IEC104_AsduQueue_Copy_Asdu(&entry, bytes, sizeof(bytes)) == IEC104_ASDU_QUEUE_OK);
|
||
CHECK(entry.asdu_length == 248U && bytes[0] == 30U && bytes[1] == 22U);
|
||
} else {
|
||
CHECK(queue.normal_queue.stored_asdu_count == 2U && status.dropped_pending_asdus == 0U && !status.overflow);
|
||
}
|
||
sp_close();
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:在成功入队后的统计查询注入失败/无效/矛盾快照。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:帧已经接手,不能回滚或重交。
|
||
* 只增加accounting_errors;后续正常Publish恢复本次增量计量,不补算此前未知覆盖数。
|
||
*/
|
||
static void test_spontaneous_accounting_failures(void)
|
||
{
|
||
const unsigned slots = IEC104_TCP_NORMAL_CAPACITY / (IEC104_ASDU_NORMAL_ENTRY_HEADER_LEN + 10U);
|
||
IEC104_SpontaneousChange_t change;
|
||
IEC104_SpontaneousStatus_t status;
|
||
unsigned i;
|
||
sp_open(true, NULL);
|
||
for (i = 0U; i < slots; ++i) { sp_external_enqueue(); }
|
||
change = sp_change();
|
||
sp_query_fail_at = sp_query_count + 2U;
|
||
sp_publish_all(&change, 1U);
|
||
CHECK(IEC104_Spontaneous_Get_Status(sp_publisher, &status));
|
||
CHECK(status.accounting_errors == 1U && status.asdus == 1U && status.dropped_pending_asdus == 0U && !status.overflow);
|
||
sp_query_invalid_at = sp_query_count + 2U;
|
||
sp_publish_all(&change, 1U);
|
||
CHECK(IEC104_Spontaneous_Get_Status(sp_publisher, &status));
|
||
CHECK(status.accounting_errors == 2U && status.asdus == 2U && status.dropped_pending_asdus == 0U && !status.overflow);
|
||
sp_query_inconsistent_at = sp_query_count + 2U;
|
||
sp_publish_all(&change, 1U);
|
||
CHECK(IEC104_Spontaneous_Get_Status(sp_publisher, &status));
|
||
CHECK(status.accounting_errors == 3U && status.asdus == 3U && status.dropped_pending_asdus == 0U && !status.overflow);
|
||
sp_publish_all(&change, 1U);
|
||
CHECK(IEC104_Spontaneous_Get_Status(sp_publisher, &status));
|
||
CHECK(status.accounting_errors == 3U && status.asdus == 4U && status.dropped_pending_asdus == 1U && status.overflow);
|
||
sp_close();
|
||
}
|
||
|
||
/* ============================================================================
|
||
* [SPONTANEOUS/LIFECYCLE] 会话用例:断线、重发、ACK与服务恢复
|
||
* ============================================================================ */
|
||
/**
|
||
* 功能:验证以下场景与约束:离线入NORMAL后销毁重建业务实例不丢原文。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:STOP暂停发送,START继续。
|
||
* EOF把未ACK原文恢复为待发,重连重发后ACK才释放;Close再Init则清空旧队列。
|
||
*/
|
||
static void test_spontaneous_connection_lifecycle(void)
|
||
{
|
||
IEC104_SpontaneousConfig_t config;
|
||
IEC104_SlaveConfig_t slave_config;
|
||
IEC104_SpontaneousChange_t change;
|
||
IEC104_TcpServerStatus_t queue;
|
||
const uint8_t *wire;
|
||
size_t wire_length;
|
||
unsigned i;
|
||
sp_open(true, NULL);
|
||
change = sp_change(); change.forms = 2U; change.station_id = 0U; change.ioa = 0xffffffU;
|
||
change.time_kind = IEC104_SPONTANEOUS_TIME_UTC; change.time_ms = 1704067200123ULL;
|
||
sp_publish_all(&change, 1U);
|
||
queue = sp_transport_status();
|
||
CHECK(!queue.connected && queue.normal_queue.pending_asdu_count == 1U && fake.sent_bytes == 0U);
|
||
CHECK(IEC104_Spontaneous_Destroy(sp_publisher));
|
||
queue = sp_transport_status();
|
||
CHECK(queue.normal_queue.pending_asdu_count == 1U);
|
||
test_spontaneous_config(&config); config.originator_address = 0x56U;
|
||
sp_publisher = IEC104_Spontaneous_Create(sp_slave, &config);
|
||
CHECK(sp_publisher != NULL);
|
||
sp_connect();
|
||
wire = sp_wire_frame(0U, &wire_length);
|
||
CHECK(wire != NULL && wire_length == 17U && wire[9] == 1U);
|
||
CHECK(wire[6] == 0xffU && wire[7] == 0xffU && wire[8] == 0xffU);
|
||
push(stop_act, sizeof(stop_act));
|
||
for (i = 0U; i < 4U; ++i) { sp_poll(); }
|
||
CHECK(sut->connection.link_state.dt_state == IEC104_DT_STOPPED);
|
||
change.value.single = 0U;
|
||
sp_publish_all(&change, 1U);
|
||
for (i = 0U; i < 4U; ++i) { sp_poll(); }
|
||
CHECK(sp_wire_frame(1U, &wire_length) == NULL);
|
||
queue = sp_transport_status();
|
||
CHECK(queue.normal_queue.pending_asdu_count == 1U && queue.normal_queue.stored_asdu_count == 2U);
|
||
push(start_act, sizeof(start_act));
|
||
for (i = 0U; i < 4U; ++i) { sp_poll(); }
|
||
wire = sp_wire_frame(1U, &wire_length);
|
||
CHECK(wire != NULL && wire_length == 17U && wire[9] == 0U);
|
||
sp_disconnect();
|
||
queue = sp_transport_status();
|
||
CHECK(queue.normal_queue.pending_asdu_count == 2U);
|
||
fake.sent_bytes = 0U;
|
||
sp_connect();
|
||
wire = sp_wire_frame(0U, &wire_length);
|
||
CHECK(wire != NULL && wire[9] == 1U);
|
||
wire = sp_wire_frame(1U, &wire_length);
|
||
CHECK(wire != NULL && wire[9] == 0U);
|
||
push_ack(2U);
|
||
for (i = 0U; i < 4U; ++i) { sp_poll(); }
|
||
queue = sp_transport_status();
|
||
CHECK(queue.normal_queue.pending_asdu_count == 0U && queue.normal_queue.stored_asdu_count == 0U);
|
||
sp_publish_all(&change, 1U);
|
||
CHECK(IEC104_Slave_Close(sp_slave, NULL) == IEC104_TCP_OK);
|
||
test_transport_config(&slave_config);
|
||
CHECK(IEC104_Slave_Init(sp_slave, &slave_config, NULL) == IEC104_TCP_EVENTS_PENDING);
|
||
sp_drain();
|
||
sp_initialize();
|
||
queue = sp_transport_status();
|
||
CHECK(queue.normal_queue.pending_asdu_count == 0U && queue.normal_queue.stored_asdu_count == 0U);
|
||
sp_close();
|
||
}
|
||
|
||
/**
|
||
* 功能:验证以下场景与约束:在队列检查或双报第二帧提交处失败后,走Close、读空通知、Init恢复服务。
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:无。
|
||
* 说明:不猜测故障前有多少原文仍可安全重试;显式重建后才从空队列重新发布。
|
||
*/
|
||
static void test_spontaneous_service_recovery(void)
|
||
{
|
||
unsigned fault;
|
||
for (fault = 0U; fault < 3U; ++fault) {
|
||
IEC104_SpontaneousChange_t change;
|
||
IEC104_SpontaneousPublishInfo_t info;
|
||
IEC104_SlaveConfig_t config;
|
||
IEC104_TcpServerStatus_t status;
|
||
sp_open(true, NULL);
|
||
change = sp_change();
|
||
sp_publish_all(&change, 1U);
|
||
sp_connect();
|
||
change.forms = 3U;
|
||
if (fault == 0U) { sp_query_invalid_at = sp_query_count + 1U; }
|
||
else {
|
||
sp_enqueue_fail_at = sp_enqueue_count + 2U;
|
||
sp_enqueue_failure = fault == 1U ? IEC104_TCP_SUBMIT_ERROR : IEC104_TCP_SUBMIT_FATAL;
|
||
}
|
||
CHECK(IEC104_Spontaneous_Publish(sp_publisher, &change, 1U, &info) == IEC104_SPONTANEOUS_PUBLISH_ERROR);
|
||
CHECK(info.error == (fault == 0U ? IEC104_SPONTANEOUS_ERROR_QUEUE : IEC104_SPONTANEOUS_ERROR_SUBMIT));
|
||
CHECK(info.published == 0U);
|
||
CHECK(IEC104_Slave_Close(sp_slave, NULL) == IEC104_TCP_OK);
|
||
test_transport_config(&config);
|
||
CHECK(IEC104_Slave_Init(sp_slave, &config, NULL) == IEC104_TCP_EVENTS_PENDING);
|
||
sp_drain();
|
||
sp_initialize();
|
||
status = sp_transport_status();
|
||
CHECK(status.normal_queue.pending_asdu_count == 0U && status.normal_queue.stored_asdu_count == 0U);
|
||
sp_enqueue_fail_at = sp_query_invalid_at = 0U;
|
||
sp_publish_all(&change, 1U);
|
||
sp_close();
|
||
}
|
||
}
|
||
|
||
|
||
|
||
|
||
|
||
|
||
/* ============================================================================
|
||
* [ENTRY/MAIN] 测试入口:配置、编码、时间、覆盖及会话
|
||
* ============================================================================ */
|
||
/**
|
||
* 功能:测试入口:配置、编码、时间、覆盖及会话
|
||
* 输入参数:无。
|
||
* 输出参数:无。
|
||
* 返回值:正常完成返回 0;参数、运行或断言失败以非零状态结束进程。
|
||
* 说明:本辅助入口用于构造或核对上述测试场景,相关状态保存在当前测试夹具中。
|
||
*/
|
||
int main(void)
|
||
{
|
||
/* [RUN/CONFIGURATION] 配置、基准与输入校验 */
|
||
test_spontaneous_configuration_and_pool();
|
||
test_spontaneous_time_base_lifecycle();
|
||
test_spontaneous_preconditions();
|
||
test_spontaneous_validation();
|
||
/* [RUN/BASE_ENCODING] 基础监视类型编码与分批 */
|
||
test_spontaneous_encoding();
|
||
test_spontaneous_signal_default_forms();
|
||
test_spontaneous_frame_limits();
|
||
test_spontaneous_segments_and_repeated_ioa();
|
||
test_spontaneous_business_priority();
|
||
test_spontaneous_partial_submit();
|
||
/* [RUN/EXTENDED] 扩展监视类型与保护品质 */
|
||
test_spontaneous_extended_encoding();
|
||
test_spontaneous_extended_limits();
|
||
test_spontaneous_extended_validation();
|
||
test_spontaneous_extended_repeated_ioa();
|
||
test_spontaneous_protection_time_quality();
|
||
test_spontaneous_totals_partial_submit();
|
||
test_spontaneous_float_totals_validation();
|
||
test_spontaneous_float_totals_partial_submit();
|
||
/* [RUN/TIME] 时间转换和快照重试 */
|
||
test_spontaneous_utc_times();
|
||
test_spontaneous_monotonic_times();
|
||
test_spontaneous_time_snapshot_and_retry();
|
||
/* [RUN/OVERWRITE] 队列覆盖与计数 */
|
||
test_spontaneous_compact_capacity();
|
||
test_spontaneous_deferred_soe();
|
||
test_spontaneous_compact_validation_and_partial();
|
||
test_spontaneous_pending_overwrite();
|
||
test_spontaneous_submitted_and_restored_overwrite();
|
||
test_spontaneous_dual_retention();
|
||
test_spontaneous_accounting_failures();
|
||
/* [RUN/LIFECYCLE] 断线、重发与恢复 */
|
||
test_spontaneous_connection_lifecycle();
|
||
test_spontaneous_service_recovery();
|
||
printf("Spontaneous: groups=30 TCP=%u NORMAL=%u instance=%zu bytes OK\n",
|
||
(unsigned)IEC104_TCP_SERVER_CAPACITY, (unsigned)IEC104_TCP_NORMAL_CAPACITY,
|
||
sizeof(IEC104_Spontaneous_t));
|
||
return 0;
|
||
}
|