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

2261 lines
106 KiB
C
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
/* 突发上送专项:可控Net配合真实服务队列,分别检查入队原文、网络写出和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;
}