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

1669 lines
86 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.
/* 国网 Type210 文件服务专项:真实 Slave/TCP/发送队列 + 可控内存网络。
* 协议期望由本文件独立构造;不调用被测模块的内部编解码函数。
* 矩阵:TCP 1/2 × 请求槽 1/2 × 写数据段 1/2/4,HIGH=251。
* 故障替身只在 IEC104_FILE_SERVICE_TEST_HOOKS 构建中链接,生产构建不含它们。
*/
#include "iec104_test_config.h"
#include "iec104_tcp_fixture.h"
#include "IEC104_FileService.h"
#ifndef IEC104_FILE_SERVICE_TASK_CAPACITY
#define IEC104_FILE_SERVICE_TASK_CAPACITY 2U
#endif
#ifndef IEC104_FILE_SERVICE_SEGMENT_CAPACITY
#define IEC104_FILE_SERVICE_SEGMENT_CAPACITY 2U
#endif
typedef struct {
IEC104_Slave_t *slave;
IEC104_FileService_t *module;
IEC104_Station_t stations[3];
IEC104_FileServiceConfig_t config;
IEC104_SlaveEvent_t input;
IEC104_FileServiceEventResult_t handled;
IEC104_FileServiceRequest_t last;
unsigned ns, nr, calls[8], lists, reads, writes, closes;
unsigned high_fault, idle_fault, check_fault, query_fault, close_fault, capacity_fault;
unsigned stop_status_poison;
unsigned open_result, commit_result, list_mode, open_name_mode, callback_fault;
unsigned rows, name_width, read_size, list_fail_at, read_fail_at, write_fail_at;
unsigned resources, directory_resources, read_resources, write_resources;
unsigned next_handle, record_count, busy_steps, last_list_index, last_read_offset;
uint32_t committed_size;
bool reenter, list_repeated, read_repeated, clock_override, stop_observed;
uint64_t module_now;
uint64_t last_response_ticket;
uint8_t entry_name[218], read_data[1024], staging[2048], committed[2048];
uint8_t records[256][249];
size_t lengths[256];
bool record_idle[256];
IEC104_SlaveEventIdentity_t closed_identity;
} fixture_t;
static fixture_t fs;
static unsigned groups;
static const uint8_t timestamp[7] = {0,0,30,10,8,11,26};
#undef CHECK
#define CHECK(x) do { if (!(x)) { fprintf(stderr, "group=%u %s:%d: %s\n", groups, __func__, __LINE__, #x); exit(1); } } while (0)
/**
* 功能:返回模拟时钟。
* 输入参数:无。
* 输出参数:无。
* 返回值:本次采样的时钟毫秒值。
* 说明:独立覆盖值用于在不改变 TCP 时基的情况下注入模块时钟回退。
*/
uint64_t IEC104_FileService_Test_Now_Ms(void) { return fs.clock_override?fs.module_now:fake.now; }
/**
* 功能:按故障开关注入身份检查错误、待分派事件或过期状态,其余情况使用真实 Slave 检查。
* 输入参数:slave——被测 Slave 实例(只读);identity——请求所属的 Slave、实例及连接代次身份(只读)。
* 输出参数:无。
* 返回值:请求身份的可执行、待事件、过期或错误状态。
* 说明:本辅助入口用于构造或核对上述测试场景,相关状态保存在当前测试夹具中。
*/
IEC104_SlaveRequestState_t IEC104_FileService_Test_Check_Request(
const IEC104_Slave_t *slave, const IEC104_SlaveEventIdentity_t *identity)
{
if (fs.check_fault == 1U) return IEC104_SLAVE_REQUEST_ERROR;
if (fs.check_fault == 2U) return IEC104_SLAVE_REQUEST_WAIT_EVENTS;
if (fs.check_fault == 3U) return IEC104_SLAVE_REQUEST_STALE;
return IEC104_Slave_Check_Request(slave, identity);
}
/**
* 功能:读取真实连接状态,并按场景覆盖查询失败、待处理事件或 STOP 例外所需的单项谓词。
* 输入参数:slave——被测 Slave 实例(只读);status——状态快照;error——底层错误码存储。
* 输出参数:status——状态快照;error——底层错误码存储。
* 返回值:真实传输接口或故障注入产生的 TCP 操作结果。
* 说明:本辅助入口用于构造或核对上述测试场景,相关状态保存在当前测试夹具中。
*/
IEC104_TcpResult_t IEC104_FileService_Test_Get_Status(const IEC104_Slave_t *slave,
IEC104_TcpServerStatus_t *status, IEC104_TcpError_t *error)
{
IEC104_TcpResult_t result;
if (fs.query_fault != 0U) return IEC104_TCP_INTERNAL_ERROR;
result=IEC104_Slave_Get_Status(slave,status,error);
/* 人工 WAIT_EVENTS 与只读快照保持一致;另有真实未分派STOP用例独立验证。 */
if(result==IEC104_TCP_OK && fs.check_fault==2U)status->pending_event_count=1U;
if(result==IEC104_TCP_OK && fs.stop_observed) {
switch(fs.stop_status_poison) {
case 1: return IEC104_TCP_INTERNAL_ERROR;
case 2: ++status->generation;break;
case 3: status->connected=false;break;
case 4: status->connection_status_valid=false;break;
case 5: status->asdu_queue_status_valid=false;break;
case 6: status->connection.phase=IEC104_TCP_SESSION_CLOSED;break;
case 7: status->connection.fault=IEC104_TCP_FAULT_INTERNAL;break;
case 8: status->connection.data_transfer_started=true;break;
case 9: status->pending_event_count=0;break;
default: break;
}
}
return result;
}
/**
* 功能:为发送容量查询注入失败,正常路径仍读取 Slave 的实际窗口容量。
* 输入参数:slave——被测 Slave 实例(只读);capacity——发送窗口和队列容量快照存储;error——底层错误码存储。
* 输出参数:capacity——实际发送窗口和队列容量快照;error——底层错误码存储。
* 返回值:真实传输接口或故障注入产生的 TCP 操作结果。
* 说明:本辅助入口用于构造或核对上述测试场景,相关状态保存在当前测试夹具中。
*/
IEC104_TcpResult_t IEC104_FileService_Test_Get_Send_Capacity(const IEC104_Slave_t *slave,
IEC104_TcpSendCapacity_t *capacity, IEC104_TcpError_t *error)
{
if (fs.capacity_fault != 0U) return IEC104_TCP_INTERNAL_ERROR;
return IEC104_Slave_Get_Send_Capacity(slave,capacity,error);
}
/**
* 功能:仅记录发送层真正接手的 ASDU。
* 输入参数:response——响应 ASDU(只读);idle——是否记录为 IDLE 数据发送。
* 输出参数:无。
* 返回值:无。
* 说明:WAIT 的候选帧不能冒充一次成功回复。
*/
static void record(const IEC60870_Asdu_t *response, bool idle)
{
const uint8_t *bytes;
uint16_t length;
CHECK(fs.record_count < 256U);
CHECK(IEC60870_Asdu_Get_Data(response,&bytes,&length) == IEC60870_ASDU_OK);
CHECK(length <= 249U);
memcpy(fs.records[fs.record_count],bytes,length);
fs.lengths[fs.record_count] = length;
fs.record_idle[fs.record_count++] = idle;
}
/**
* 功能:注入确认发送的 WAIT、错误及未分派 STOP。
* 输入参数:slave——被测 Slave 实例;identity——请求所属的 Slave、实例及连接代次身份(只读);response——响应 ASDU(只读);ticket——发送跟踪票据。
* 输出参数:ticket——提交成功时返回的跟踪票据。
* 返回值:发送提交结果,区分接收成功、WAIT、ERROR 与 FATAL。
* 说明:正常提交使用 FILE_CALL 优先级,
* 仅成功接收后保存响应票据与报文字节,供确认顺序和控制/数据依赖断言。
*/
IEC104_TcpSubmitResult_t IEC104_FileService_Test_Send_Response(IEC104_Slave_t *slave,
const IEC104_SlaveEventIdentity_t *identity, const IEC60870_Asdu_t *response, uint64_t *ticket)
{
IEC104_TcpSubmitResult_t result;
if (fs.high_fault == 1U) return IEC104_TCP_SUBMIT_WAIT;
if (fs.high_fault == 2U) return IEC104_TCP_SUBMIT_ERROR;
if (fs.high_fault == 3U) return IEC104_TCP_SUBMIT_FATAL;
if (fs.high_fault == 4U || fs.high_fault == 5U) {
push(stop_act,sizeof(stop_act));
CHECK(IEC104_Slave_Poll(slave,0,NULL) == IEC104_TCP_OK);
fs.stop_observed=true;
return fs.high_fault == 4U ? IEC104_TCP_SUBMIT_ERROR : IEC104_TCP_SUBMIT_FATAL;
}
result = IEC104_Slave_Send_Response_Tracked_Priority(slave,identity,response,ticket,
IEC104_BUSINESS_PRIORITY_FILE_CALL);
if (result == IEC104_TCP_SUBMIT_OK) {
if(ticket!=NULL)fs.last_response_ticket=*ticket;
record(response,false);
}
return result;
}
/**
* 功能:注入文件数据发送准入结果或 STOP 竞态,其余路径按 FILE_TRANSFER 优先级及预留窗口查询。
* 输入参数:slave——被测 Slave 实例(只读);identity——请求所属的 Slave、实例及连接代次身份(只读);reserve——保留的发送窗口数量。
* 输出参数:无。
* 返回值:发送提交结果,区分接收成功、WAIT、ERROR 与 FATAL。
* 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。
*/
IEC104_TcpSubmitResult_t IEC104_FileService_Test_Query_Idle_Send(const IEC104_Slave_t *slave,
const IEC104_SlaveEventIdentity_t *identity, uint16_t reserve)
{
if (fs.idle_fault == 1U) return IEC104_TCP_SUBMIT_WAIT;
if (fs.idle_fault == 2U) return IEC104_TCP_SUBMIT_ERROR;
if (fs.idle_fault == 3U) return IEC104_TCP_SUBMIT_FATAL;
if (fs.idle_fault == 11U) return IEC104_TCP_SUBMIT_OK;
if (fs.idle_fault == 7U || fs.idle_fault == 8U) {
push(stop_act,sizeof(stop_act));CHECK(IEC104_Slave_Poll(fs.slave,0,NULL)==IEC104_TCP_OK);
return fs.idle_fault==7U?IEC104_TCP_SUBMIT_ERROR:IEC104_TCP_SUBMIT_FATAL;
}
return IEC104_Slave_Query_Idle_Send_Priority(slave,identity,reserve,IEC104_BUSINESS_PRIORITY_FILE_TRANSFER);
}
/**
* 功能:注入数据提交阶段的 WAIT、错误或 STOP 竞态。
* 输入参数:slave——被测 Slave 实例;identity——请求所属的 Slave、实例及连接代次身份(只读);response——响应 ASDU(只读);reserve——保留的发送窗口数量。
* 输出参数:无。
* 返回值:发送提交结果,区分接收成功、WAIT、ERROR 与 FATAL。
* 说明:正常提交成功后才记录 IDLE 数据帧。
*/
IEC104_TcpSubmitResult_t IEC104_FileService_Test_Send_Idle(IEC104_Slave_t *slave,
const IEC104_SlaveEventIdentity_t *identity, const IEC60870_Asdu_t *response, uint16_t reserve)
{
IEC104_TcpSubmitResult_t result;
if (fs.idle_fault == 4U) return IEC104_TCP_SUBMIT_WAIT;
if (fs.idle_fault == 5U) return IEC104_TCP_SUBMIT_ERROR;
if (fs.idle_fault == 6U) return IEC104_TCP_SUBMIT_FATAL;
if (fs.idle_fault == 9U || fs.idle_fault == 10U) {
push(stop_act,sizeof(stop_act));CHECK(IEC104_Slave_Poll(slave,0,NULL)==IEC104_TCP_OK);
return fs.idle_fault==9U?IEC104_TCP_SUBMIT_ERROR:IEC104_TCP_SUBMIT_FATAL;
}
result = IEC104_Slave_Send_Idle_Priority(slave,identity,response,reserve,IEC104_BUSINESS_PRIORITY_FILE_TRANSFER);
if (result == IEC104_TCP_SUBMIT_OK) record(response,true);
return result;
}
/**
* 功能:记录关链次数和目标身份,并可模拟关链失败。
* 输入参数:slave——被测 Slave 实例;identity——请求所属的 Slave、实例及连接代次身份(只读);error——底层错误码存储。
* 输出参数:error——底层错误码存储。
* 返回值:真实传输接口或故障注入产生的 TCP 操作结果。
* 说明:正常路径只关闭身份匹配的连接。
*/
IEC104_TcpResult_t IEC104_FileService_Test_Close_Connection(IEC104_Slave_t *slave,
const IEC104_SlaveEventIdentity_t *identity, IEC104_TcpError_t *error)
{
++fs.closes; fs.closed_identity = *identity;
if (fs.close_fault != 0U) return IEC104_TCP_INTERNAL_ERROR;
return IEC104_Slave_Close_Connection_By_Identity(slave,identity,error);
}
/**
* 功能:取得模块状态快照,查询失败立即终止当前测试。
* 输入参数:无。
* 输出参数:无。
* 返回值:按值返回的当前状态或信息快照。
* 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。
*/
static IEC104_FileServiceStatus_t status(void)
{
IEC104_FileServiceStatus_t result;
CHECK(IEC104_FileService_Get_Status(fs.module,&result));
return result;
}
/**
* 功能:核对回调身份与执行状态。
* 输入参数:request——当前业务请求(只读)。
* 输出参数:无。
* 返回值:无。
* 说明:启用重入探针时验证修改入口拒绝嵌套调用,取消也不改变待办数量。
*/
static void reentry_check(const IEC104_FileServiceRequest_t *request)
{
IEC104_FileServiceStatus_t before = status(), after;
CHECK(request->identity.slave == fs.slave && request->station_id != 0U);
CHECK(request->instance_id != 0U && request->receive_serial != 0U);
CHECK(!before.execute_ready);
if (!fs.reenter) return;
CHECK(!IEC104_FileService_Destroy(fs.module));
CHECK(!IEC104_FileService_Process(fs.module));
CHECK(IEC104_FileService_Handle_Event(fs.module,&fs.input) == IEC104_FILE_SERVICE_EVENT_ERROR);
CHECK(IEC104_FileService_Execute_Next(fs.module,NULL,NULL) == IEC104_FILE_SERVICE_EXECUTE_ERROR);
IEC104_FileService_Cancel(fs.module);
after = status();
CHECK(after.pending_requests == before.pending_requests && after.pending_segments == before.pending_segments);
}
/**
* 功能:模拟目录、读文件及暂存写资源的打开和结束,记录句柄、结束原因与提交内容。
* 输入参数:context——业务回调的测试上下文;request——当前业务请求(只读);open——打开回调的文件句柄与属性。
* 输出参数:open——打开成功时返回的资源句柄、大小和可选文件名。
* 返回值:文件资源动作的成功或业务错误结果。
* 说明:可注入打开/提交失败或回调后的身份检查故障,并核对 TEST 写不会触及业务资源。
*/
static IEC104_FileServiceResult_t action(void *context,
const IEC104_FileServiceRequest_t *request, IEC104_FileServiceOpen_t *open)
{
CHECK(context == &fs && request->call >= 1 && request->call <= 7);
reentry_check(request);
++fs.calls[request->call]; fs.last = *request;
if (request->call == IEC104_FILE_SERVICE_CALL_OPEN_DIRECTORY ||
request->call == IEC104_FILE_SERVICE_CALL_OPEN_READ || request->call == IEC104_FILE_SERVICE_CALL_OPEN_WRITE) {
CHECK(open != NULL && open->size == 0U && open->handle == 0U && open->name == NULL);
if (fs.open_result != 0U) return (IEC104_FileServiceResult_t)fs.open_result;
open->handle = ++fs.next_handle;
++fs.resources;
if (request->call == IEC104_FILE_SERVICE_CALL_OPEN_DIRECTORY) ++fs.directory_resources;
else if (request->call == IEC104_FILE_SERVICE_CALL_OPEN_READ) {
++fs.read_resources; open->size = fs.read_size;
if (fs.open_name_mode != 0U) {
open->name = (const uint8_t *)"PATH/H";
open->name_length = fs.open_name_mode == 1U ? 6U : 0U;
}
} else { CHECK(!request->test); ++fs.write_resources; memset(fs.staging,0,sizeof(fs.staging)); }
} else {
CHECK(open == NULL && request->name == NULL && request->name_length == 0U);
CHECK(fs.resources > 0U); --fs.resources;
if (request->call == IEC104_FILE_SERVICE_CALL_CLOSE_DIRECTORY) { CHECK(fs.directory_resources == 1U); --fs.directory_resources; }
else if (request->call == IEC104_FILE_SERVICE_CALL_CLOSE_READ) { CHECK(fs.read_resources == 1U); --fs.read_resources; }
else {
CHECK(!request->test && fs.write_resources > 0U); --fs.write_resources;
if (request->call == IEC104_FILE_SERVICE_CALL_COMMIT) {
if (fs.commit_result == 0U) {
CHECK(request->transferred <= sizeof(fs.committed));
memcpy(fs.committed,fs.staging,request->transferred); fs.committed_size = request->transferred;
}
if (fs.callback_fault != 0U) fs.check_fault = 1U;
return (IEC104_FileServiceResult_t)fs.commit_result;
}
}
}
if (fs.callback_fault != 0U) fs.check_fault = 1U;
return IEC104_FILE_SERVICE_RESULT_OK;
}
/**
* 功能:按游标生成目录条目并统计重复枚举。
* 输入参数:context——业务回调的测试上下文;request——当前业务请求(只读);index——待访问或核对的条目下标;entry——目录条目输出存储。
* 输出参数:entry——本次枚举的名称、大小及时间。
* 返回值:目录枚举结果,区分条目、结束、无目录和错误。
* 说明:可注入结束、目录不存在、非法输出及时间筛选样本。
*/
static IEC104_FileServiceListResult_t list(void *context,
const IEC104_FileServiceRequest_t *request, size_t index, IEC104_FileServiceEntry_t *entry)
{
CHECK(context == &fs && request->call == IEC104_FILE_SERVICE_CALL_NONE);
CHECK(fs.directory_resources == 1U && request->handle != 0U);
reentry_check(request);
CHECK(entry->name == NULL && entry->name_length == 0U && entry->size == 0U);
if (fs.lists > 0U && fs.last_list_index == index) fs.list_repeated = true;
fs.last_list_index = (unsigned)index; ++fs.lists;
if (fs.list_mode == 1U || (fs.list_mode == 9U && index != 0U)) return IEC104_FILE_SERVICE_LIST_NO_DIRECTORY;
if (fs.list_mode == 2U || (fs.list_fail_at != 0U && index >= fs.list_fail_at)) return IEC104_FILE_SERVICE_LIST_ERROR;
if (fs.list_mode == 5U) return (IEC104_FileServiceListResult_t)99;
if (index >= fs.rows && fs.list_mode != 8U) return IEC104_FILE_SERVICE_LIST_END;
entry->name = fs.list_mode == 3U ? NULL : fs.entry_name;
entry->name_length = (uint8_t)fs.name_width;
entry->size = (uint32_t)index + 3U;
entry->time.time.year = 2026; entry->time.time.month = 11; entry->time.time.day = 8;
entry->time.time.hour = 10; entry->time.time.minute = 30;
if (fs.list_mode == 4U) entry->time.time.month = 13;
if (fs.list_mode == 6U) entry->time.is_invalid = 1;
if (fs.list_mode == 7U) entry->time.time.year = 2025;
if (fs.list_mode == 10U && (index % 3U != 0U || index > 6U)) entry->time.time.year = 2025;
if (fs.callback_fault != 0U) fs.check_fault = 1U;
return IEC104_FILE_SERVICE_LIST_ENTRY;
}
/**
* 功能:检查读句柄和偏移范围后复制模拟文件数据,统计同偏移重读,并支持指定位置及回调后故障。
* 输入参数:context——业务回调的测试上下文;request——当前业务请求(只读);offset——文件、记录或缓冲区偏移;buffer——文件数据缓冲区;length——字节长度。
* 输出参数:buffer——写入或读出的数据字节。
* 返回值:true 表示本次操作或核对成功;false 表示拒绝、失败或命中注入故障。
* 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。
*/
static bool read_file(void *context, const IEC104_FileServiceRequest_t *request,
uint32_t offset, uint8_t *buffer, uint16_t length)
{
CHECK(context == &fs && request->call == IEC104_FILE_SERVICE_CALL_NONE && request->name == NULL);
CHECK(fs.read_resources == 1U && offset <= fs.read_size && length <= fs.read_size - offset);
reentry_check(request);
if (fs.reads > 0U && fs.last_read_offset == offset) fs.read_repeated = true;
fs.last_read_offset = offset; ++fs.reads;
if (fs.read_fail_at != 0U && offset >= fs.read_fail_at - 1U) return false;
memcpy(buffer,fs.read_data + offset,length);
if (fs.callback_fault != 0U) fs.check_fault = 1U;
return true;
}
/**
* 功能:校验普通写段的暂存边界与末段标志,再写入暂存区。
* 输入参数:context——业务回调的测试上下文;request——当前业务请求(只读);offset——文件、记录或缓冲区偏移;data——数据片段(只读);length——字节长度;last——末段标志或范围终点。
* 输出参数:无。
* 返回值:true 表示本次操作或核对成功;false 表示拒绝、失败或命中注入故障。
* 说明:可在指定调用或回调返回后注入失败。
*/
static bool write_file(void *context, const IEC104_FileServiceRequest_t *request,
uint32_t offset, const uint8_t *data, uint16_t length, bool last)
{
CHECK(context == &fs && request->call == IEC104_FILE_SERVICE_CALL_NONE && request->name == NULL && !request->test);
CHECK(fs.write_resources > 0U && offset <= sizeof(fs.staging) && length <= sizeof(fs.staging) - offset);
CHECK(offset + length <= request->file_size && (!last || offset + length == request->file_size));
reentry_check(request); ++fs.writes;
if (fs.write_fail_at != 0U && fs.writes >= fs.write_fail_at) return false;
memcpy(fs.staging + offset,data,length);
if (fs.callback_fault != 0U) fs.check_fault = 1U;
return true;
}
static const IEC104_FileServiceHandlers_t handlers = {list,action,read_file,write_file};
/**
* 功能:使用本测试的业务回调和上下文执行一个文件服务工作步骤。
* 输入参数:无。
* 输出参数:无。
* 返回值:单步执行结果,区分已执行、无任务、等待及错误。
* 说明:本辅助入口用于构造或核对上述测试场景,相关状态保存在当前测试夹具中。
*/
static IEC104_FileServiceExecuteResult_t execute(void)
{ return IEC104_FileService_Execute_Next(fs.module,&handlers,&fs); }
/**
* 功能:BUSY 的同一事件始终保留在本栈帧,绝不先读后续通知。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:每一步都断言协议规定上界。
*/
static void events(void)
{
IEC104_SlaveEvent_t event;
IEC104_TcpEventResult_t next;
while ((next = IEC104_Slave_NextEvent(fs.slave,&event)) == IEC104_TCP_EVENT_READY) {
IEC104_FileServiceEventResult_t result;
unsigned steps = 0;
do {
result = IEC104_FileService_Handle_Event(fs.module,&event);
if (result == IEC104_FILE_SERVICE_EVENT_BUSY) {
CHECK(++steps <= IEC104_FILE_SERVICE_BUSY_STEP_LIMIT);
CHECK(execute() == IEC104_FILE_SERVICE_EXECUTE_OK);
++fs.busy_steps;
}
} while (result == IEC104_FILE_SERVICE_EVENT_BUSY);
CHECK(result != IEC104_FILE_SERVICE_EVENT_ERROR);
if (event.transport.type == IEC104_TCP_EVENT_I_FRAME) {
CHECK(IEC104_Slave_Copy_Event(&fs.input,&event)); fs.handled = result;
}
}
CHECK(next == IEC104_TCP_EVENT_EMPTY);
}
/**
* 功能:轮询并分派 Slave 事件,消费实际发送帧以推进接收确认号,连接存续时回送 ACK。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。
*/
static void poll_fs(void)
{
size_t offset = 0;
CHECK(IEC104_Slave_Poll(fs.slave,0,NULL) == IEC104_TCP_OK); events();
while (offset < fake.sent_bytes) {
const uint8_t *frame = fake.output + offset;
size_t length = (size_t)frame[1] + 2U;
CHECK(length >= 6U && offset + length <= fake.sent_bytes);
if ((frame[2] & 1U) == 0U) fs.nr = (((unsigned)frame[2] >> 1) | ((unsigned)frame[3] << 7)) + 1U;
offset += length;
}
fake.sent_bytes = 0;
if (fs.nr > 0U && sut->client_socket != IEC104_NET_INVALID_SOCKET) push_ack(fs.nr);
}
/**
* 功能:交替轮询和处理模块四轮,推进确认发送而不主动执行业务回调。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。
*/
static void flush(void)
{
unsigned i;
for (i = 0; i < 4U; ++i) { poll_fs(); CHECK(IEC104_FileService_Process(fs.module)); }
}
/**
* 功能:有界推进事件、业务执行和确认,直至待执行、待回复及请求队列均清空。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:超出轮数即判失败。
*/
static void settle(void)
{
unsigned i;
for (i = 0; i < 128U; ++i) {
IEC104_FileServiceStatus_t state;
poll_fs(); CHECK(IEC104_FileService_Process(fs.module));
CHECK(execute() != IEC104_FILE_SERVICE_EXECUTE_ERROR);
CHECK(IEC104_FileService_Process(fs.module));
state = status();
if (!state.execute_pending && state.pending_replies == 0U && state.pending_requests == 0U) { flush(); return; }
}
CHECK(false);
}
/**
* 功能:按当前收发序号封装不超过 249 字节的 ASDU 并注入网络输入,暂不轮询。
* 输入参数:bytes——报文字节缓冲区(只读);size——数据长度或文件大小。
* 输出参数:无。
* 返回值:无。
* 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。
*/
static void queue(const uint8_t *bytes, size_t size)
{
uint8_t frame[255] = {0x68};
CHECK(size <= 249U);
frame[1] = (uint8_t)(size + 4U); frame[2] = (uint8_t)(fs.ns << 1);
frame[3] = (uint8_t)(fs.ns >> 7); ++fs.ns;
frame[4] = (uint8_t)(fs.nr << 1); frame[5] = (uint8_t)(fs.nr >> 7);
memcpy(frame + 6,bytes,size); push(frame,size + 6U);
}
/**
* 功能:注入一个请求帧并轮询分派事件,使后续断言可观察接收后的模块状态。
* 输入参数:bytes——报文字节缓冲区(只读);size——数据长度或文件大小。
* 输出参数:无。
* 返回值:无。
* 说明:本辅助入口用于构造或核对上述测试场景,相关状态保存在当前测试夹具中。
*/
static void send_fs(const uint8_t *bytes, size_t size) { queue(bytes,size); poll_fs(); }
/**
* 功能:重置夹具,建立双站 Slave 与文件服务,并通过真实 START 握手进入工作态。
* 输入参数:custom——可选文件服务配置(只读)。
* 输出参数:无。
* 返回值:无。
* 说明:可覆盖模块配置,默认目录及文件数据保持确定性。
*/
static void open_config(const IEC104_FileServiceConfig_t *custom)
{
IEC104_SlaveConfig_t config;
unsigned i;
memset(&fs,0,sizeof(fs)); memset(&fake,0,sizeof(fake)); fake.now = 1000;
fs.rows = 3U; fs.name_width = 1U; fs.read_size = 500U;
memset(fs.entry_name,'H',sizeof(fs.entry_name));
for (i = 0; i < sizeof(fs.read_data); ++i) fs.read_data[i] = (uint8_t)i;
fs.slave = IEC104_Slave_Create(); CHECK(fs.slave != NULL);
test_transport_config(&config); config.protocol.link.k = 32;
config.protocol.link.t1_ms = config.protocol.link.t3_ms = config.protocol.local_send_timeout_ms = 600000U;
CHECK(IEC104_Slave_Init(fs.slave,&config,NULL) == IEC104_TCP_OK);
CHECK(IEC104_Slave_Add_Station(fs.slave,&fs.stations[0],1,&fs) == IEC104_STATION_OK);
CHECK(IEC104_Slave_Add_Station(fs.slave,&fs.stations[1],2,&fs) == IEC104_STATION_OK);
IEC104_FileService_Config_Default(&fs.config); if (custom != NULL) fs.config = *custom;
fs.module = IEC104_FileService_Create(fs.slave,&fs.config); CHECK(fs.module != NULL);
sut = NULL;
for (i = 0; i < IEC104_TCP_SERVER_CAPACITY; ++i) if (server_pool[i].in_use) { sut = &server_pool[i].server; break; }
CHECK(sut != NULL);
fake.accept_pending = 1U; poll_fs(); push(start_act,sizeof(start_act)); poll_fs();
CHECK(status().active); fake.sent_bytes = 0;
}
/**
* 功能:使用默认文件服务配置建立已启动的测试连接。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:本辅助入口用于构造或核对上述测试场景,相关状态保存在当前测试夹具中。
*/
static void open_fs(void) { open_config(NULL); }
/**
* 功能:清除故障注入,取消业务并关链,执行剩余资源清理后销毁模块、站点和 Slave,核对无资源残留。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。
*/
static void close_fs(void)
{
unsigned i;
fs.query_fault = fs.check_fault = fs.high_fault = fs.idle_fault = fs.close_fault = fs.callback_fault = 0U;
fs.stop_observed=false;
IEC104_FileService_Cancel(fs.module);
CHECK(IEC104_Slave_Close(fs.slave,NULL) == IEC104_TCP_OK); events();
for (i = 0; status().finish_pending && i < 8U; ++i) CHECK(execute() == IEC104_FILE_SERVICE_EXECUTE_OK);
CHECK(fs.resources == 0U && !status().finish_pending);
CHECK(IEC104_FileService_Destroy(fs.module));
for (i = 0; i < 3U; ++i) {
if (IEC104_Station_Is_Registered(&fs.stations[i]))
CHECK(IEC104_Slave_Remove_Station(fs.slave,&fs.stations[i]) == IEC104_STATION_OK);
CHECK(IEC104_Station_Is_Reusable(&fs.stations[i]));
}
CHECK(IEC104_Slave_Destroy(fs.slave,NULL) == IEC104_TCP_OK);
}
/**
* 功能:将 32 位无符号值按小端序写入报文缓冲区的四个字节。
* 输入参数:bytes——报文字节缓冲区;value——测试对象值或原始位模式。
* 输出参数:bytes——写入或读出的数据字节。
* 返回值:无。
* 说明:本辅助入口用于构造或核对上述测试场景,相关状态保存在当前测试夹具中。
*/
static void u32(uint8_t *bytes, uint32_t value)
{ bytes[0]=(uint8_t)value; bytes[1]=(uint8_t)(value>>8); bytes[2]=(uint8_t)(value>>16); bytes[3]=(uint8_t)(value>>24); }
/**
* 功能:从报文中的四个小端字节还原无符号值,供编号和偏移断言使用。
* 输入参数:bytes——报文字节缓冲区(只读)。
* 输出参数:无。
* 返回值:四个小端字节还原的无符号 32 位值。
* 说明:本辅助入口用于构造或核对上述测试场景,相关状态保存在当前测试夹具中。
*/
static uint32_t le32(const uint8_t *bytes)
{ return bytes[0] | ((uint32_t)bytes[1]<<8) | ((uint32_t)bytes[2]<<16) | ((uint32_t)bytes[3]<<24); }
/**
* 功能:清空报文缓冲区并填入 Type 210、站地址及指定操作和传送原因的公共头。
* 输入参数:bytes——报文字节缓冲区;op——文件服务操作码;cause——完整传送原因字节。
* 输出参数:bytes——写入或读出的数据字节。
* 返回值:无。
* 说明:本辅助入口用于构造或核对上述测试场景,相关状态保存在当前测试夹具中。
*/
static void prefix(uint8_t *bytes, uint8_t op, uint8_t cause)
{
memset(bytes,0,249U); bytes[0]=210; bytes[1]=1; bytes[2]=cause;
bytes[3]=0x35; bytes[4]=1; bytes[9]=2; bytes[10]=op;
}
/**
* 功能:生成固定长度目录召唤。
* 输入参数:bytes——报文字节缓冲区;cause——完整传送原因字节;filter——是否启用目录时间筛选。
* 输出参数:bytes——写入或读出的数据字节。
* 返回值:生成报文或结果数据的实际字节长度。
* 说明:启用筛选时填入相同起止时刻,返回报文长度。
*/
static size_t directory(uint8_t *bytes, uint8_t cause, bool filter)
{
prefix(bytes,1,cause); bytes[16]=filter?1:0;
if (filter) { memcpy(bytes+17,timestamp,7); memcpy(bytes+24,timestamp,7); }
return 31U;
}
/**
* 功能:生成文件 H 的读或写激活报文,写请求带编号与长度,TEST 标志随请求写入。
* 输入参数:bytes——报文字节缓冲区;write——是否构造写激活;size——数据长度或文件大小;id——文件编号;test——是否设置 TEST 位。
* 输出参数:bytes——写入或读出的数据字节。
* 返回值:生成报文或结果数据的实际字节长度。
* 说明:本辅助入口用于构造或核对上述测试场景,相关状态保存在当前测试夹具中。
*/
static size_t activation(uint8_t *bytes, bool write, uint32_t size, uint32_t id, bool test)
{
prefix(bytes,write?7:3,test?0x86:6); bytes[11]=1; bytes[12]='H';
if (write) { u32(bytes+13,id); u32(bytes+17,size); }
return write?21U:13U;
}
/**
* 功能:生成带编号、偏移、后续段标志和累加校验的写数据段,单段数据不得超过 228 字节。
* 输入参数:bytes——报文字节缓冲区;id——文件编号;offset——文件、记录或缓冲区偏移;data——数据片段(只读);length——字节长度;more——是否还有后续数据段;test——是否设置 TEST 位。
* 输出参数:bytes——写入或读出的数据字节。
* 返回值:生成报文或结果数据的实际字节长度。
* 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。
*/
static size_t segment(uint8_t *bytes, uint32_t id, uint32_t offset, const uint8_t *data, size_t length, bool more, bool test)
{
size_t i; uint8_t sum=0;
CHECK(length<=228U); prefix(bytes,9,test?0x85:5); u32(bytes+11,id); u32(bytes+15,offset); bytes[19]=more?1:0;
for(i=0;i<length;++i) { bytes[20+i]=data[i]; sum=(uint8_t)(sum+data[i]); }
bytes[20+length]=sum; return 21U+length;
}
/**
* 功能:按长度和字节逐项核对已接收的响应,不匹配时打印实际与期望报文后终止测试。
* 输入参数:index——待访问或核对的条目下标;bytes——报文字节缓冲区(只读);length——字节长度。
* 输出参数:无。
* 返回值:无。
* 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。
*/
static void expect(unsigned index, const uint8_t *bytes, size_t length)
{
size_t i;
CHECK(fs.record_count>index);
if(fs.lengths[index]!=length||memcmp(fs.records[index],bytes,length)!=0) {
fprintf(stderr,"group=%u record=%u actual(%zu):",groups,index,fs.lengths[index]);
for(i=0;i<fs.lengths[index];++i) fprintf(stderr," %02X",fs.records[index][i]);
fprintf(stderr,"\nexpected(%zu):",length);
for(i=0;i<length;++i) fprintf(stderr," %02X",bytes[i]);
fprintf(stderr,"\n"); CHECK(false);
}
}
/**
* 功能:核对指定响应的文件服务类型、操作码及该操作对应位置的结果码。
* 输入参数:index——待访问或核对的条目下标;op——文件服务操作码;code——期望协议结果码。
* 输出参数:无。
* 返回值:无。
* 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。
*/
static void result(unsigned index, uint8_t op, uint8_t code)
{
CHECK(fs.record_count>index && fs.records[index][0]==210 && fs.records[index][10]==op);
CHECK(fs.records[index][op==10?19:11]==code);
}
/**
* 功能:发送写激活并执行一次业务步骤,再推进激活确认发送。
* 输入参数:size——数据长度或文件大小;id——文件编号;test——是否设置 TEST 位。
* 输出参数:无。
* 返回值:无。
* 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。
*/
static void activate_write(uint32_t size, uint32_t id, bool test)
{
uint8_t bytes[249]; send_fs(bytes,activation(bytes,true,size,id,test));
CHECK(execute()==IEC104_FILE_SERVICE_EXECUTE_OK); flush();
}
/**
* 功能:发送读激活并执行打开文件步骤,再推进激活确认发送。
* 输入参数:test——是否设置 TEST 位。
* 输出参数:无。
* 返回值:无。
* 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。
*/
static void activate_read(bool test)
{
uint8_t bytes[249]; send_fs(bytes,activation(bytes,false,0,0,test));
CHECK(execute()==IEC104_FILE_SERVICE_EXECUTE_OK); flush();
}
/**
* 功能:验证以下场景与约束:配置拒绝不占用实例槽。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:缺回调时连 TEST 和清理也不能进入部分执行。
*/
static void test_configuration(void)
{
IEC104_FileServiceConfig_t config, bad;
IEC104_SlaveConfig_t transport;
IEC104_FileServiceHandlers_t missing = handlers;
uint8_t bytes[249];
IEC104_FileService_Config_Default(NULL);
IEC104_FileService_Config_Default(&config);
CHECK(config.features==7 && config.segment_mode==IEC104_FILE_SERVICE_SEGMENT_OFFSET);
CHECK(config.write_confirm_mode==0 && config.read_confirm_mode==0 && config.id_mode==0);
CHECK(!config.allow_short_directory_request && config.write_confirm_cause==7);
CHECK(config.read_segment_bytes==228 && config.window_reserve==2 && config.list_scan_budget==64);
CHECK(config.reply_timeout_ms==15000 && config.directory_timeout_ms==60000);
CHECK(IEC104_FileService_Create(NULL,&config)==NULL && !IEC104_FileService_Destroy(NULL));
CHECK(!IEC104_FileService_Process(NULL));
open_fs(); CHECK(IEC104_FileService_Create(fs.slave,&config)==NULL);
CHECK(IEC104_FileService_Create(fs.slave,NULL)==NULL);
CHECK(IEC104_Slave_Close(fs.slave,NULL)==IEC104_TCP_OK);events();
CHECK(IEC104_FileService_Destroy(fs.module)); fs.module=NULL;
#define BAD_CONFIG(field,value) do { bad=config; bad.field=(value); CHECK(IEC104_FileService_Create(fs.slave,&bad)==NULL); } while(0)
BAD_CONFIG(features,0); BAD_CONFIG(features,8);
BAD_CONFIG(segment_mode,(IEC104_FileServiceSegmentMode_t)9);
BAD_CONFIG(write_confirm_mode,(IEC104_FileServiceWriteConfirmMode_t)9);
BAD_CONFIG(read_confirm_mode,(IEC104_FileServiceReadConfirmMode_t)9);
BAD_CONFIG(id_mode,(IEC104_FileServiceIdMode_t)9);
BAD_CONFIG(write_confirm_cause,6); BAD_CONFIG(read_segment_bytes,0); BAD_CONFIG(read_segment_bytes,229);
BAD_CONFIG(window_reserve,0); BAD_CONFIG(list_scan_budget,0); BAD_CONFIG(reply_timeout_ms,0);
#undef BAD_CONFIG
fs.module=IEC104_FileService_Create(fs.slave,&config); CHECK(fs.module!=NULL);
/* 新建模块必须重新收到CONNECTED,不能偷用当前Slave状态自行激活。 */
test_transport_config(&transport);transport.protocol.link.k=32;
CHECK(IEC104_Slave_Init(fs.slave,&transport,NULL)==IEC104_TCP_OK);
fake.accept_pending=1;poll_fs();push(start_act,sizeof(start_act));poll_fs();
send_fs(bytes,activation(bytes,true,4,0,false)); missing.write=NULL;
CHECK(IEC104_FileService_Execute_Next(fs.module,&missing,&fs)==IEC104_FILE_SERVICE_EXECUTE_ERROR);
CHECK(fs.calls[IEC104_FILE_SERVICE_CALL_OPEN_WRITE]==0U);
close_fs();
}
/**
* 功能:验证原因、站地址、IOA 及操作结构的拒绝码和校验优先级,同时覆盖广播地址、异常段及 VSQ 归一化。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。
*/
static void test_wire_validation(void)
{
static const struct { unsigned field; uint8_t value,cot; size_t length; } cases[]={
{2,10,0x6d,13},{4,99,0x6e,13},{6,1,0x6f,13},
{9,3,0x47,13},{10,2,0x47,13},{2,0x46,0x47,13},
{2,5,0x6d,13},{0,210,0x47,6}
};
uint8_t bytes[249],expected[249]; unsigned i;
open_fs();
for(i=0;i<sizeof(cases)/sizeof(cases[0]);++i) {
activation(bytes,false,0,0,false);bytes[cases[i].field]=cases[i].value;
memcpy(expected,bytes,cases[i].length);expected[2]=cases[i].cot;
fs.record_count=0;send_fs(bytes,cases[i].length);settle();expect(0,expected,cases[i].length);
}
activation(bytes,false,0,0,false);bytes[4]=bytes[5]=255;
memcpy(expected,bytes,13);expected[2]=0x6e;fs.record_count=0;send_fs(bytes,13);settle();expect(0,expected,13);
activation(bytes,false,0,0,false);bytes[2]=10;bytes[4]=99;bytes[6]=1;
memcpy(expected,bytes,13);expected[2]=0x6d;fs.record_count=0;send_fs(bytes,13);settle();expect(0,expected,13);
prefix(bytes,9,5);bytes[9]=9;fs.record_count=0;send_fs(bytes,21);settle();CHECK(fs.record_count==0);
activation(bytes,false,0,0,false);bytes[1]=0xff;fs.record_count=0;send_fs(bytes,13);settle();
CHECK(fs.records[0][1]==1 && fs.calls[IEC104_FILE_SERVICE_CALL_OPEN_READ]==1U);
close_fs();
}
/**
* 功能:覆盖空名、过长名、截断及多余字节,核对目录请求的严格长度与可选短格式开关。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。
*/
static void test_lengths_and_names(void)
{
uint8_t bytes[249]; unsigned i;
open_fs();
for(i=0;i<3U;++i) {
size_t n=activation(bytes,true,4,0,false);
bytes[11]=(uint8_t)(i==0?0:i==1?229:1);
fs.record_count=0;send_fs(bytes,i==2?n-1:n);settle();result(0,8,i==2?1:2);
}
activation(bytes,false,0,0,false);fs.record_count=0;send_fs(bytes,12);settle();result(0,4,1);
activation(bytes,false,0,0,false);fs.record_count=0;send_fs(bytes,14);settle();result(0,4,1);
directory(bytes,5,false);fs.record_count=0;send_fs(bytes,17);settle();result(0,2,1);CHECK(fs.records[0][2]==5);
directory(bytes,6,false);fs.record_count=0;send_fs(bytes,30);settle();result(0,2,1);CHECK(fs.records[0][2]==0x47);
directory(bytes,5,false);bytes[15]=219;fs.record_count=0;send_fs(bytes,249);settle();result(0,2,1);
close_fs();
{
IEC104_FileServiceConfig_t config;IEC104_FileService_Config_Default(&config);config.allow_short_directory_request=true;
open_config(&config);directory(bytes,5,false);fs.rows=0;send_fs(bytes,17);settle();result(0,2,0);
fs.record_count=0;send_fs(bytes,18);settle();result(0,2,1);close_fs();
}
}
/**
* 功能:验证读写激活及目录条目的最大合法文件名可完整装入 249 字节响应。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。
*/
static void test_maximum_names(void)
{
uint8_t bytes[249];
open_fs();fs.read_size=0;prefix(bytes,3,6);bytes[11]=228;memset(bytes+12,'N',228);
send_fs(bytes,240);CHECK(execute()==IEC104_FILE_SERVICE_EXECUTE_OK);flush();
CHECK(fs.lengths[0]==249 && fs.records[0][12]==228 && memcmp(fs.records[0]+13,bytes+12,228)==0);
settle();fs.record_count=0;prefix(bytes,7,6);bytes[11]=228;memset(bytes+12,'W',228);u32(bytes+240,0);u32(bytes+244,0);
send_fs(bytes,248);settle();CHECK(fs.lengths[0]==249 && fs.records[0][12]==228);result(1,10,0);close_fs();
open_fs();directory(bytes,5,false);bytes[15]=218;memset(bytes+16,'D',218);memset(bytes+234,0,15);
fs.name_width=218;fs.rows=1;send_fs(bytes,249);settle();
CHECK(fs.lengths[0]==249 && fs.records[0][17]==1 && fs.records[0][18]==218);close_fs();
}
/**
* 功能:对照独立字节向量核对多条目、空目录及目录不存在的响应,并检查目录资源和统计计数。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。
*/
static void test_directory_vectors(void)
{
uint8_t bytes[249],expected[249];unsigned i;size_t cursor=18;
open_fs();send_fs(bytes,directory(bytes,5,false));settle();
prefix(expected,2,5);expected[17]=3;
for(i=0;i<3U;++i) { expected[cursor]=1;expected[cursor+1]='H';u32(expected+cursor+3,i+3U);memcpy(expected+cursor+7,timestamp,7);cursor+=14; }
expect(0,expected,cursor);CHECK(fs.record_count==1 && fs.calls[1]==1 && fs.calls[2]==1);
CHECK(status().directories==1 && status().directory_frames==1);close_fs();
open_fs();fs.rows=0;send_fs(bytes,directory(bytes,6,false));settle();prefix(expected,2,7);expect(0,expected,18);close_fs();
open_fs();fs.list_mode=1;send_fs(bytes,directory(bytes,6,false));settle();prefix(expected,2,0x47);expected[11]=1;expect(0,expected,18);
CHECK(status().directory_failures==1 && fs.calls[2]==1);close_fs();
}
/**
* 功能:验证长条目按容量分页及后续帧标志。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:确认发送 WAIT 时暂不发布,恢复后完成且资源只关闭一次。
*/
static void test_directory_frames_and_wait(void)
{
uint8_t bytes[249];unsigned before;
open_fs();fs.name_width=100;fs.rows=5;send_fs(bytes,directory(bytes,5,false));
CHECK(execute()==IEC104_FILE_SERVICE_EXECUTE_OK);CHECK(fs.lists==0);
fs.high_fault=1;CHECK(execute()==IEC104_FILE_SERVICE_EXECUTE_WAIT);CHECK(fs.record_count==0);before=fs.lists;
fs.high_fault=0;CHECK(execute()==IEC104_FILE_SERVICE_EXECUTE_OK);flush();CHECK(fs.lists>before);
settle();CHECK(fs.record_count==3);
CHECK(fs.records[0][16]==1 && fs.records[1][16]==1 && fs.records[2][16]==0);
CHECK(fs.records[0][17]==2 && fs.records[1][17]==2 && fs.records[2][17]==1);
CHECK(fs.calls[1]==1 && fs.calls[2]==1);close_fs();
}
/**
* 功能:验证大量被筛除条目仍受单步扫描预算限制,并核对单条目预算和无效时间标志的筛选规则。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。
*/
static void test_directory_budget_filter(void)
{
IEC104_FileServiceConfig_t config;uint8_t bytes[249];unsigned i,before;
IEC104_FileService_Config_Default(&config);config.list_scan_budget=64;
open_config(&config);fs.rows=10000;fs.list_mode=7;send_fs(bytes,directory(bytes,5,true));
CHECK(execute()==IEC104_FILE_SERVICE_EXECUTE_OK);
for(i=0;i<160 && fs.calls[2]==0;++i) { before=fs.lists;CHECK(execute()==IEC104_FILE_SERVICE_EXECUTE_OK);CHECK(fs.lists-before<=64);flush(); }
CHECK(fs.lists==10001 && fs.record_count==1 && fs.records[0][17]==0);close_fs();
config.list_scan_budget=1;open_config(&config);send_fs(bytes,directory(bytes,5,true));settle();
CHECK(fs.record_count==3 && fs.records[2][17]==1 && fs.records[2][16]==0);close_fs();
open_fs();fs.list_mode=6;send_fs(bytes,directory(bytes,5,true));settle();CHECK(fs.records[0][17]==0);close_fs();
open_fs();fs.list_mode=6;send_fs(bytes,directory(bytes,5,false));settle();CHECK(fs.records[0][17]==3 && (fs.records[0][27]&0x80)!=0);close_fs();
}
/**
* 功能:验证以下场景与约束:匹配项0/3/6后还有大量过滤项。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:预算1及长名分页都须在真实末项结束。
* 首帧背压时重复重建同一页,每轮包括前瞻在内不超过扫描预算。
*/
static void test_directory_lookahead(void)
{
static const unsigned budgets[]={1U,2U,64U}, widths[]={1U,100U,218U};
IEC104_FileServiceConfig_t config;
uint8_t bytes[249];
unsigned b,w,step,before,i,seen;
for(b=0;b<sizeof(budgets)/sizeof(budgets[0]);++b) {
for(w=0;w<sizeof(widths)/sizeof(widths[0]);++w) {
IEC104_FileService_Config_Default(&config);config.list_scan_budget=(uint16_t)budgets[b];
open_config(&config);fs.rows=19;fs.list_mode=10;fs.name_width=widths[w];
send_fs(bytes,directory(bytes,5,true));CHECK(execute()==IEC104_FILE_SERVICE_EXECUTE_OK);
fs.high_fault=1;
for(step=0;step<100;++step) {
IEC104_FileServiceExecuteResult_t result_value;
before=fs.lists;result_value=execute();CHECK(fs.lists-before<=budgets[b]);
CHECK(result_value==IEC104_FILE_SERVICE_EXECUTE_OK || result_value==IEC104_FILE_SERVICE_EXECUTE_WAIT);
CHECK(fs.record_count==0);
if(result_value==IEC104_FILE_SERVICE_EXECUTE_WAIT)break;
}
CHECK(step<100);before=fs.lists;
CHECK(execute()==IEC104_FILE_SERVICE_EXECUTE_WAIT && fs.lists-before<=budgets[b]);
fs.high_fault=0;
for(step=0;step<128;++step) {
before=fs.lists;CHECK(execute()==IEC104_FILE_SERVICE_EXECUTE_OK);
CHECK(fs.lists-before<=budgets[b]);flush();
if(fs.calls[IEC104_FILE_SERVICE_CALL_CLOSE_DIRECTORY]!=0U)break;
}
CHECK(step<128 && status().directories==1 && fs.record_count!=0U);
seen=0;
for(i=0;i<fs.record_count;++i) {
size_t cursor=18U;
unsigned entry;
CHECK(fs.records[i][10]==2 && fs.records[i][11]==0 && fs.records[i][17]!=0);
CHECK(fs.records[i][16]==(i+1U==fs.record_count?0U:1U));
for(entry=0;entry<fs.records[i][17];++entry) {
unsigned length=fs.records[i][cursor];
CHECK(length==widths[w] && le32(fs.records[i]+cursor+2U+length)==3U+seen*3U);
CHECK(memcmp(fs.records[i]+cursor+1U,fs.entry_name,length)==0);
cursor+=13U+length;++seen;
}
CHECK(cursor==fs.lengths[i]);
}
CHECK(seen==3U && fs.calls[IEC104_FILE_SERVICE_CALL_OPEN_DIRECTORY]==1U);
close_fs();
}
}
IEC104_FileService_Config_Default(&config);config.list_scan_budget=1;
open_config(&config);send_fs(bytes,directory(bytes,5,false));
CHECK(execute()==IEC104_FILE_SERVICE_EXECUTE_OK);
CHECK(execute()==IEC104_FILE_SERVICE_EXECUTE_OK && fs.record_count==0);
fs.list_fail_at=1;settle();result(0,2,1);
CHECK(fs.record_count==1 && fs.records[0][17]==0 && status().directory_failures==1);close_fs();
}
/**
* 功能:验证以下场景与约束:注入非法条目、日期及枚举返回值,核对错误确认和回调异常计数。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:已分页后的终止确认 WAIT 不再枚举。
*/
static void test_directory_output_errors(void)
{
uint8_t bytes[249];unsigned mode,before;
for(mode=2;mode<=5;++mode) {
open_fs();fs.list_mode=mode;send_fs(bytes,directory(bytes,6,false));settle();result(0,2,1);
CHECK(fs.calls[1]==1 && fs.calls[2]==1 && status().directory_failures==1);
if(mode>=3) CHECK(status().invalid_callbacks==1);
close_fs();
}
open_fs();fs.list_mode=9;send_fs(bytes,directory(bytes,6,false));settle();result(0,2,1);
CHECK(status().invalid_callbacks==1 && fs.calls[2]==1);close_fs();
open_fs();fs.name_width=218;fs.rows=3;send_fs(bytes,directory(bytes,5,false));CHECK(execute()==IEC104_FILE_SERVICE_EXECUTE_OK);
CHECK(execute()==IEC104_FILE_SERVICE_EXECUTE_OK);flush();CHECK(fs.record_count==1);
fs.list_mode=2;fs.high_fault=1;CHECK(execute()==IEC104_FILE_SERVICE_EXECUTE_OK);before=fs.lists;
fs.list_mode=0;CHECK(execute()==IEC104_FILE_SERVICE_EXECUTE_OK);CHECK(fs.calls[2]==1);
CHECK(IEC104_FileService_Process(fs.module));CHECK(fs.lists==before);
fs.high_fault=0;flush();CHECK(fs.record_count==2 && fs.records[1][11]==1 && fs.records[1][16]==0 && fs.records[1][17]==0);close_fs();
}
/**
* 功能:覆盖 CP56Time2a 非法日期、时间及保留位,验证可忽略标志位和倒置筛选区间的处理。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。
*/
static void test_time_validation(void)
{
static const struct { unsigned byte;uint8_t value; } bad[]={
{18,0xea},{19,0x80},{20,0x20},{21,30},{22,13},{22,0x1b},{23,0x80}
};
uint8_t bytes[249];unsigned i;
open_fs();
for(i=0;i<sizeof(bad)/sizeof(bad[0]);++i) {
directory(bytes,5,true);bytes[bad[i].byte]=bad[i].value;
if(i==0)bytes[17]=0x60;
if(i==3)bytes[22]=2;
fs.record_count=0;send_fs(bytes,31);settle();result(0,2,1);
}
directory(bytes,5,true);bytes[19]|=0x40;bytes[20]|=0x80;bytes[21]|=0xe0;
fs.record_count=0;send_fs(bytes,31);settle();result(0,2,0);CHECK(fs.records[0][17]==3);
directory(bytes,5,true);bytes[21]=9;fs.record_count=0;send_fs(bytes,31);settle();result(0,2,0);CHECK(fs.records[0][17]==0);
close_fs();
}
/**
* 功能:核对读激活和数据段的精确字节、校验和及发送优先级,并覆盖空文件与回调替换文件名。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。
*/
static void test_read_vectors(void)
{
uint8_t expected[249];
open_fs();fs.read_size=3;memcpy(fs.read_data,"ABC",3);activate_read(false);settle();
prefix(expected,4,7);expected[12]=1;expected[13]='H';u32(expected+18,3);expect(0,expected,22);
prefix(expected,5,5);memcpy(expected+20,"ABC",3);expected[23]=0xc6;expect(1,expected,24);
CHECK(!fs.record_idle[0] && fs.record_idle[1]);CHECK(status().reads_completed==1 && fs.calls[6]==1);
CHECK(fs.last.reason==IEC104_FILE_SERVICE_END_COMPLETE && fs.last.transferred==3);close_fs();
open_fs();fs.read_size=0;activate_read(false);settle();prefix(expected,5,5);expect(1,expected,21);close_fs();
open_fs();fs.open_name_mode=1;fs.read_size=0;activate_read(false);settle();
CHECK(fs.lengths[0]==27 && fs.records[0][12]==6 && memcmp(fs.records[0]+13,"PATH/H",6)==0);close_fs();
}
/**
* 功能:验证连续分段的偏移和校验。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:准入 WAIT 不读文件,提交 WAIT 重读原偏移,
* 中途读失败后保留空终止段,确认等待期间不再调用读回调。
*/
static void test_read_stream_wait_abort(void)
{
unsigned i,offset=0,before;uint8_t sum;
open_fs();activate_read(false);settle();CHECK(fs.record_count==4);
for(i=1;i<4;++i) {
unsigned n=(unsigned)fs.lengths[i]-21U,j;sum=0;
CHECK(fs.record_idle[i] && le32(fs.records[i]+15)==offset);
CHECK(fs.records[i][19]==(i==3?0:1));
for(j=0;j<n;++j) { CHECK(fs.records[i][20+j]==(uint8_t)(offset+j));sum=(uint8_t)(sum+fs.records[i][20+j]); }
CHECK(fs.records[i][20+n]==sum);offset+=n;
}
CHECK(offset==500);close_fs();
open_fs();activate_read(false);fs.idle_fault=1;
CHECK(execute()==IEC104_FILE_SERVICE_EXECUTE_WAIT && fs.reads==0);
CHECK(status().idle_waiting && !status().execute_ready);
fs.idle_fault=4;CHECK(execute()==IEC104_FILE_SERVICE_EXECUTE_WAIT && fs.reads==1 && status().read_offset==0);
fs.idle_fault=0;CHECK(execute()==IEC104_FILE_SERVICE_EXECUTE_OK);flush();CHECK(fs.reads==2 && fs.read_repeated);
fs.read_fail_at=229;fs.idle_fault=4;CHECK(execute()==IEC104_FILE_SERVICE_EXECUTE_WAIT);before=fs.reads;
fs.read_fail_at=0;fs.idle_fault=0;settle();CHECK(fs.reads==before);
CHECK(fs.lengths[2]==21 && fs.records[2][19]==0 && fs.records[2][2]==5 && le32(fs.records[2]+15)==228);
CHECK(status().reads_aborted==1 && status().reads_completed==0 && fs.last.reason==IEC104_FILE_SERVICE_END_ERROR);close_fs();
}
/**
* 功能:核对三种主站读确认策略、重复确认计数及跨站确认隔离,确认结束时保留主站结束原因。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。
*/
static void test_read_confirm_modes(void)
{
IEC104_FileServiceConfig_t config;uint8_t bytes[249];unsigned mode;
for(mode=0;mode<3;++mode) {
IEC104_FileService_Config_Default(&config);config.read_confirm_mode=(IEC104_FileServiceReadConfirmMode_t)mode;
open_config(&config);activate_read(false);
prefix(bytes,6,5);bytes[19]=1;send_fs(bytes,20);
CHECK(status().read_confirms==1 && status().read_confirm_nonzero==1);
if(mode==0) { CHECK(status().read_active);settle();CHECK(status().reads_completed==1); }
else { CHECK(status().finish_pending);CHECK(execute()==IEC104_FILE_SERVICE_EXECUTE_OK);CHECK(fs.last.reason==IEC104_FILE_SERVICE_END_MASTER); }
send_fs(bytes,20);CHECK(status().read_confirms==2);
bytes[4]=2;send_fs(bytes,20);CHECK(status().rejected>=1);close_fs();
}
}
/**
* 功能:验证打开失败不清理未取得资源,非法替换文件名会关闭已取得句柄,TEST 读标志传递到响应与结束回调。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。
*/
static void test_read_open_failure_and_test(void)
{
unsigned mode;uint8_t bytes[249];
for(mode=1;mode<=4;++mode) {
open_fs();fs.open_result=mode;send_fs(bytes,activation(bytes,false,0,0,false));settle();result(0,4,1);
CHECK(fs.calls[6]==0 && !status().read_active);close_fs();
}
open_fs();fs.open_name_mode=2;send_fs(bytes,activation(bytes,false,0,0,false));settle();result(0,4,1);
CHECK(fs.calls[6]==1 && status().invalid_callbacks==1);close_fs();
open_fs();fs.read_size=3;activate_read(true);settle();CHECK(fs.records[0][2]==0x87 && fs.records[1][2]==0x85 && fs.last.test);close_fs();
}
/**
* 功能:对照字节向量完成两段写入,核对暂存数据、唯一提交、最终确认及成功统计,过程中不调用 ABORT。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。
*/
static void test_write_vectors(void)
{
uint8_t bytes[249],expected[249],data[]={1,2,3,4};
open_fs();activate_write(4,17,false);
prefix(expected,8,7);expected[12]=1;expected[13]='H';u32(expected+18,4);expect(0,expected,22);
send_fs(bytes,segment(bytes,17,0,data,2,true,false));CHECK(execute()==IEC104_FILE_SERVICE_EXECUTE_OK);CHECK(fs.record_count==1);
send_fs(bytes,segment(bytes,17,2,data+2,2,false,false));CHECK(execute()==IEC104_FILE_SERVICE_EXECUTE_OK);
CHECK(status().finish_pending);CHECK(execute()==IEC104_FILE_SERVICE_EXECUTE_OK);flush();
prefix(expected,10,7);u32(expected+15,2);expect(1,expected,20);
CHECK(fs.writes==2 && fs.calls[5]==1 && fs.calls[7]==0 && fs.committed_size==4 && memcmp(fs.committed,data,4)==0);
CHECK(status().writes_committed==1 && status().segments_written==2);close_fs();
}
/**
* 功能:覆盖校验和、编号、偏移、长度及写回调失败等段错误,核对结果码优先级、唯一 ABORT 和禁止提交。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。
*/
static void test_write_errors(void)
{
uint8_t bytes[249],data[]={1,2,3,4};unsigned mode;
for(mode=0;mode<8;++mode) {
size_t n;
open_fs();activate_write(4,17,false);
n=segment(bytes,17,0,data,mode==4?3:4,false,false);
if(mode==0) { bytes[19]=2;bytes[n-1]^=1;bytes[11]=18; }
if(mode==1) { bytes[n-1]^=1;bytes[11]=18; }
if(mode==2) { bytes[11]=18;bytes[15]=1; }
if(mode==3)bytes[15]=1;
if(mode==5)fs.write_fail_at=1;
if(mode==6)n=segment(bytes,17,0,data,0,true,false);
if(mode==7)n=20;
send_fs(bytes,n);settle();result(1,10,mode==1?2:mode==2?4:(mode==3||mode==4||mode==6)?3:1);
CHECK(fs.calls[7]==1 && fs.calls[5]==0 && status().writes_failed==1);
CHECK(fs.writes==(mode==5?1U:0U));close_fs();
}
}
/**
* 功能:验证编号回显、忽略报文偏移及逐段确认选项。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:提交失败返回错误,已结束的资源不再 ABORT。
*/
static void test_write_modes_and_commit_failure(void)
{
IEC104_FileServiceConfig_t config;uint8_t bytes[249],data[]={1,2,3,4};
IEC104_FileService_Config_Default(&config);config.id_mode=IEC104_FILE_SERVICE_ID_ECHO;
config.write_confirm_cause=5;config.segment_mode=IEC104_FILE_SERVICE_SEGMENT_UNCHECKED;config.write_confirm_mode=IEC104_FILE_SERVICE_WRITE_CONFIRM_EACH;
open_config(&config);activate_write(4,99,false);CHECK(le32(fs.records[0]+14)==99);
send_fs(bytes,segment(bytes,99,123,data,2,true,false));CHECK(execute()==IEC104_FILE_SERVICE_EXECUTE_OK);flush();result(1,10,0);
CHECK(fs.records[1][2]==5 && le32(fs.records[1]+11)==99 && le32(fs.records[1]+15)==123);
fs.commit_result=1;send_fs(bytes,segment(bytes,99,456,data+2,2,false,false));settle();result(2,10,1);
CHECK(fs.records[2][2]==5 && le32(fs.records[2]+15)==456 && fs.calls[5]==1 && fs.calls[7]==0 && fs.committed_size==0);close_fs();
}
/**
* 功能:核对写打开回调各种失败结果到协议结果码的映射,失败后无活动写会话且不清理未取得的资源。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。
*/
static void test_write_open_results(void)
{
uint8_t bytes[249];unsigned value;
for(value=1;value<=4;++value) {
open_fs();fs.open_result=value;send_fs(bytes,activation(bytes,true,4,0,false));settle();result(0,8,value==4?1:(uint8_t)value);
CHECK(fs.records[0][2]==0x47 && !status().write_active && fs.calls[7]==0);close_fs();
}
}
/**
* 功能:验证以下场景与约束:连发采用真实通知 FIFO。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:BUSY 期间环后面仍有未读事件,不能用先读空掩盖死锁。
*/
static void test_busy_pipeline(void)
{
uint8_t bytes[249],data[2];unsigned i;
open_fs();activate_write(24,7,false);
for(i=0;i<12;++i) { data[0]=(uint8_t)(2*i);data[1]=(uint8_t)(2*i+1);queue(bytes,segment(bytes,7,2*i,data,2,i!=11,false)); }
poll_fs();CHECK(fs.busy_steps>0 && status().busy_returns>0);settle();
CHECK(fs.writes==12 && fs.calls[5]==1 && fs.committed_size==24 && fs.record_count==2);
for(i=0;i<24;++i)CHECK(fs.committed[i]==i);
close_fs();
}
/**
* 功能:验证以下场景与约束:未分派事件阻塞 COMMIT 时仍可接收下一写事务。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:恢复后每笔只提交一次,确认保持事务接收顺序。
*/
static void test_commit_wait_and_order(void)
{
uint8_t bytes[249],data[]={1,2};
open_fs();activate_write(2,1,false);fs.check_fault=2;
send_fs(bytes,segment(bytes,1,0,data,2,false,false));CHECK(execute()==IEC104_FILE_SERVICE_EXECUTE_OK);
CHECK(status().finish_pending && status().pending_replies>=1);
CHECK(execute()==IEC104_FILE_SERVICE_EXECUTE_EMPTY);CHECK(fs.calls[5]==0 && status().commit_waiting);
send_fs(bytes,activation(bytes,true,2,2,false));CHECK(execute()==IEC104_FILE_SERVICE_EXECUTE_OK);
CHECK(fs.calls[4]==2 && fs.record_count==1);
send_fs(bytes,segment(bytes,2,0,data,2,false,false));CHECK(execute()==IEC104_FILE_SERVICE_EXECUTE_OK);
CHECK(fs.calls[5]==0 && status().pending_replies>=2);
fs.check_fault=0;settle();CHECK(fs.calls[5]==2 && fs.record_count==4);
result(1,10,0);result(2,8,0);result(3,10,0);close_fs();
}
/**
* 功能:验证以下场景与约束:在末段已处理但尚未提交时注入 STOP 或主动取消,验证 COMMIT 被撤销并仅以取消原因 ABORT 一次。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。
*/
static void test_commit_stop_and_cancel(void)
{
uint8_t bytes[249],data[]={1,2};unsigned mode;
for(mode=0;mode<2;++mode) {
open_fs();activate_write(2,1,false);
send_fs(bytes,segment(bytes,1,0,data,2,false,false));CHECK(execute()==IEC104_FILE_SERVICE_EXECUTE_OK);
if(mode==0) {
push(stop_act,sizeof(stop_act));CHECK(IEC104_Slave_Poll(fs.slave,0,NULL)==IEC104_TCP_OK);
CHECK(execute()==IEC104_FILE_SERVICE_EXECUTE_EMPTY);CHECK(fs.calls[5]==0);events();
} else IEC104_FileService_Cancel(fs.module);
CHECK(execute()==IEC104_FILE_SERVICE_EXECUTE_OK);
CHECK(fs.calls[5]==0 && fs.calls[7]==1 && status().commits_cancelled==1 && fs.committed_size==0);
CHECK(fs.last.reason==IEC104_FILE_SERVICE_END_CANCELLED);close_fs();
}
}
/**
* 功能:验证零长度文件在确认 WAIT 期间合并重复末段,提交仅一次。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:提交后重发仍只保留一份最终确认。
*/
static void test_empty_pending_merge(void)
{
uint8_t bytes[249];unsigned i;
open_fs();fs.high_fault=1;activate_write(0,9,false);
CHECK(status().pending_replies>=2 && fs.calls[5]==0);
for(i=0;i<6;++i) { send_fs(bytes,segment(bytes,9,0,NULL,0,false,false));CHECK(execute()==IEC104_FILE_SERVICE_EXECUTE_OK); }
for(i=0;i<IEC104_FILE_SERVICE_SEGMENT_CAPACITY && status().pending_segments!=0U;++i)CHECK(execute()==IEC104_FILE_SERVICE_EXECUTE_OK);
CHECK(status().pending_segments==0U);
CHECK(fs.calls[5]==1 && status().pending_replies==2 && fs.record_count==0 && fs.calls[7]==0);
fs.high_fault=0;settle();CHECK(fs.record_count==2);result(0,8,0);result(1,10,0);
fs.high_fault=1;
for(i=0;i<6;++i) { send_fs(bytes,segment(bytes,9,0,NULL,0,false,false));CHECK(execute()==IEC104_FILE_SERVICE_EXECUTE_OK); }
for(i=0;i<IEC104_FILE_SERVICE_SEGMENT_CAPACITY && status().pending_segments!=0U;++i)CHECK(execute()==IEC104_FILE_SERVICE_EXECUTE_OK);
CHECK(status().pending_segments==0U);
CHECK(status().pending_replies==1 && fs.calls[5]==1);
fs.high_fault=0;settle();CHECK(fs.record_count==3);result(2,10,0);close_fs();
}
/**
* 功能:验证普通写与 TEST 写相互隔离,错误域的数据段不触及业务。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:纯 TEST 写不打开、写入、提交或释放业务资源。
*/
static void test_test_isolation(void)
{
uint8_t bytes[249],data[]={1,2};
open_fs();activate_write(2,1,false);
send_fs(bytes,activation(bytes,true,2,1,true));settle();result(1,8,1);CHECK(fs.records[1][2]==0xc7);
CHECK(fs.calls[4]==1 && fs.calls[7]==0 && status().write_active && !status().write_test);
send_fs(bytes,segment(bytes,1,0,data,2,false,true));CHECK(execute()==IEC104_FILE_SERVICE_EXECUTE_OK);CHECK(fs.writes==0);
send_fs(bytes,segment(bytes,1,0,data,2,false,false));settle();CHECK(fs.calls[5]==1);close_fs();
open_fs();activate_write(2,1,true);CHECK(status().write_test);
send_fs(bytes,segment(bytes,1,0,data,2,false,true));settle();CHECK(fs.calls[4]==0 && fs.writes==0 && fs.calls[5]==0 && fs.calls[7]==0);
result(1,10,0);CHECK(fs.records[1][2]==0x87 && status().writes_committed==0);close_fs();
open_fs();activate_write(2,1,true);activate_write(2,1,false);
CHECK(!status().write_test && fs.calls[4]==1 && fs.calls[7]==0);close_fs();
}
/**
* 功能:验证新激活先清理被替代资源、旧段成为游离段。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:确认或任务容量不足时丢弃请求而不替换现有事务。
*/
static void test_supersession_and_full(void)
{
uint8_t bytes[249],data[]={1,2};unsigned i;
open_fs();fs.idle_fault=1;activate_read(false);send_fs(bytes,activation(bytes,false,0,0,false));
CHECK(!status().read_active && status().finish_pending);CHECK(execute()==IEC104_FILE_SERVICE_EXECUTE_OK);
CHECK(fs.calls[6]==1 && fs.last.reason==IEC104_FILE_SERVICE_END_SUPERSEDED);
CHECK(execute()==IEC104_FILE_SERVICE_EXECUTE_OK);CHECK(fs.calls[3]==2);close_fs();
open_fs();activate_write(4,1,false);
send_fs(bytes,segment(bytes,1,0,data,2,true,false));
send_fs(bytes,activation(bytes,true,2,2,false));
CHECK(execute()==IEC104_FILE_SERVICE_EXECUTE_OK && fs.calls[7]==1 && fs.last.reason==IEC104_FILE_SERVICE_END_SUPERSEDED);
CHECK(execute()==IEC104_FILE_SERVICE_EXECUTE_OK && fs.calls[4]==2);
CHECK(execute()==IEC104_FILE_SERVICE_EXECUTE_OK && fs.writes==0 && status().stray_segments==1);close_fs();
open_fs();fs.high_fault=1;activate_write(4,1,false);
send_fs(bytes,activation(bytes,true,2,2,false));CHECK(status().dropped_requests==1 && fs.calls[7]==0);
close_fs();
open_fs();fs.high_fault=1;
for(i=0;i<IEC104_FILE_SERVICE_TASK_CAPACITY;++i) { directory(bytes,5,false);send_fs(bytes,31); }
send_fs(bytes,activation(bytes,false,0,0,false));CHECK(status().dropped_requests==1 && fs.calls[3]==0);close_fs();
}
/**
* 功能:验证以下场景与约束:取消后只为最近写事务的首个迟到段返回错误,后续段静默丢弃。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:多笔待提交清理按事务新旧选择标记。
*/
static void test_silent_cancel_marker(void)
{
uint8_t bytes[249],data[]={1,2};unsigned before;
open_fs();activate_write(4,1,false);IEC104_FileService_Cancel(fs.module);CHECK(execute()==IEC104_FILE_SERVICE_EXECUTE_OK);
CHECK(fs.calls[7]==1);before=fs.record_count;
send_fs(bytes,segment(bytes,1,0,data,2,true,false));settle();CHECK(fs.record_count==before+1);result(before,10,1);
send_fs(bytes,segment(bytes,1,2,data,2,false,false));settle();CHECK(fs.record_count==before+1 && status().stray_segments>=1);close_fs();
/* 两个 COMMIT 同时等待,标记须取新序号,而非清理数组遍历到的最后一项。 */
open_fs();activate_write(2,1,false);fs.check_fault=2;
send_fs(bytes,segment(bytes,1,0,data,2,false,false));CHECK(execute()==IEC104_FILE_SERVICE_EXECUTE_OK);
activation(bytes,true,2,2,false);bytes[4]=2;send_fs(bytes,21);CHECK(execute()==IEC104_FILE_SERVICE_EXECUTE_OK);
segment(bytes,2,0,data,2,false,false);bytes[4]=2;send_fs(bytes,23);CHECK(execute()==IEC104_FILE_SERVICE_EXECUTE_OK);
IEC104_FileService_Cancel(fs.module);fs.check_fault=0;
CHECK(execute()==IEC104_FILE_SERVICE_EXECUTE_OK);CHECK(execute()==IEC104_FILE_SERVICE_EXECUTE_OK);
before=fs.record_count;send_fs(bytes,segment(bytes,1,0,data,2,false,false));settle();CHECK(fs.record_count==before);
segment(bytes,2,0,data,2,false,false);bytes[4]=2;send_fs(bytes,23);settle();CHECK(fs.record_count==before+1);result(before,10,1);close_fs();
}
/**
* 功能:覆盖写段执行前超时、时钟回退及 TEST 超时,验证确认未交付前不启动写空闲计时,关闭超时后允许回退。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。
*/
static void test_write_expiry(void)
{
IEC104_FileServiceConfig_t config;uint8_t bytes[249],data[]={1,2};unsigned mode;
IEC104_FileService_Config_Default(&config);config.write_idle_timeout_ms=10;
for(mode=0;mode<3;++mode) {
open_config(&config);activate_write(4,1,mode==2);
fake.now=1009;send_fs(bytes,segment(bytes,1,0,data,2,true,mode==2));
if(mode==1) { fs.clock_override=true;fs.module_now=999; }
else fake.now=1010;
CHECK(execute()==IEC104_FILE_SERVICE_EXECUTE_OK);settle();
CHECK(fs.writes==0 && status().write_timeouts==1);result(1,10,1);
CHECK(fs.calls[7]==(mode==2?0U:1U));close_fs();
}
open_config(&config);fs.high_fault=1;activate_write(4,1,false);fake.now=1020;
send_fs(bytes,segment(bytes,1,0,data,2,true,false));CHECK(execute()==IEC104_FILE_SERVICE_EXECUTE_OK);
CHECK(fs.writes==1 && status().write_timeouts==0);fs.high_fault=0;flush();fake.now=1029;
send_fs(bytes,segment(bytes,1,2,data,2,false,false));settle();CHECK(fs.calls[5]==1);close_fs();
config.write_idle_timeout_ms=0;open_config(&config);activate_write(2,1,false);fs.clock_override=true;fs.module_now=999;
send_fs(bytes,segment(bytes,1,0,data,2,false,false));settle();CHECK(fs.calls[5]==1);close_fs();
}
/**
* 功能:验证等待执行、目录枚举及读数据超时均阻止后续业务回调,并正确返回错误或以超时原因释放已开资源。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。
*/
static void test_directory_read_deadlines(void)
{
IEC104_FileServiceConfig_t config;uint8_t bytes[249];
IEC104_FileService_Config_Default(&config);config.directory_timeout_ms=10;config.read_idle_timeout_ms=10;config.execute_timeout_ms=10;
open_config(&config);send_fs(bytes,directory(bytes,6,false));fake.now=1010;CHECK(execute()==IEC104_FILE_SERVICE_EXECUTE_OK);flush();
result(0,2,1);CHECK(fs.calls[1]==0 && status().timeouts==1);close_fs();
open_config(&config);send_fs(bytes,directory(bytes,6,false));CHECK(execute()==IEC104_FILE_SERVICE_EXECUTE_OK);
fake.now=1010;CHECK(execute()==IEC104_FILE_SERVICE_EXECUTE_OK);settle();result(0,2,1);
CHECK(fs.lists==0 && fs.calls[2]==1 && status().directory_timeouts==1 && fs.last.reason==IEC104_FILE_SERVICE_END_TIMEOUT);close_fs();
open_config(&config);activate_read(false);fs.idle_fault=1;fake.now=1010;
CHECK(execute()==IEC104_FILE_SERVICE_EXECUTE_OK);CHECK(fs.reads==0);fs.idle_fault=0;settle();
CHECK(status().read_timeouts==1 && fs.calls[6]==1 && fs.record_count==1 && fs.last.reason==IEC104_FILE_SERVICE_END_TIMEOUT);close_fs();
}
/**
* 功能:验证激活确认和待提交预留确认均受回复期限限制,超时关链并取消 COMMIT、清理写资源。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。
*/
static void test_reply_and_reserved_deadlines(void)
{
IEC104_FileServiceConfig_t config;uint8_t bytes[249],data[]={1,2};
IEC104_FileService_Config_Default(&config);config.reply_timeout_ms=10;
open_config(&config);fs.high_fault=1;activate_write(4,1,false);fake.now=1010;
CHECK(execute()==IEC104_FILE_SERVICE_EXECUTE_OK);CHECK(status().reply_timeouts==1 && fs.closes==1);
CHECK(fs.writes==0 && fs.calls[5]==0);close_fs();
open_config(&config);activate_write(2,1,false);fs.check_fault=2;
send_fs(bytes,segment(bytes,1,0,data,2,false,false));CHECK(execute()==IEC104_FILE_SERVICE_EXECUTE_OK);
fake.now=1010;CHECK(execute()==IEC104_FILE_SERVICE_EXECUTE_OK);
CHECK(fs.calls[5]==0 && status().commits_cancelled==1 && status().reply_timeouts==1 && fs.closes==1);
fs.check_fault=0;if(status().finish_pending)CHECK(execute()==IEC104_FILE_SERVICE_EXECUTE_OK);
CHECK(fs.calls[7]==1 && fs.last.reason==IEC104_FILE_SERVICE_END_TIMEOUT);close_fs();
}
/**
* 功能:覆盖发送及身份检查在业务回调前后的失败,核对故障锁定、唯一关链和资源清理。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:已提交数据不再回滚。
*/
static void test_faults_after_and_before_callbacks(void)
{
uint8_t bytes[249],data[]={1,2};unsigned mode;
for(mode=2;mode<=3;++mode) {
open_fs();send_fs(bytes,activation(bytes,true,4,0,false));fs.high_fault=mode;fs.close_fault=1;
CHECK(execute()==IEC104_FILE_SERVICE_EXECUTE_OK);CHECK(status().faulted && fs.closes==1 && fs.calls[4]==1);
CHECK(!IEC104_FileService_Process(fs.module));CHECK(execute()==IEC104_FILE_SERVICE_EXECUTE_OK);CHECK(fs.calls[7]==1);
IEC104_FileService_Cancel(fs.module);CHECK(!IEC104_FileService_Process(fs.module));CHECK(fs.closes==1);
fs.high_fault=0;send_fs(bytes,activation(bytes,true,4,0,false));CHECK(fs.handled==IEC104_FILE_SERVICE_EVENT_HANDLED && status().faulted_dropped==1);
CHECK(status().pending_requests==0 && fs.calls[4]==1);close_fs();
}
open_fs();activate_read(false);fs.idle_fault=2;
CHECK(execute()==IEC104_FILE_SERVICE_EXECUTE_ERROR);CHECK(status().faulted && fs.reads==0 && fs.closes==1);close_fs();
open_fs();activate_read(false);fs.callback_fault=1;
CHECK(execute()==IEC104_FILE_SERVICE_EXECUTE_OK);CHECK(status().faulted && fs.reads==1 && fs.closes==1);close_fs();
open_fs();activate_write(2,1,false);send_fs(bytes,segment(bytes,1,0,data,2,false,false));CHECK(execute()==IEC104_FILE_SERVICE_EXECUTE_OK);
fs.high_fault=3;CHECK(execute()==IEC104_FILE_SERVICE_EXECUTE_OK);
CHECK(fs.calls[5]==1 && fs.calls[7]==0 && fs.committed_size==2 && status().faulted);close_fs();
}
/**
* 功能:验证以下场景与约束:确认发送恰遇未分派 STOP 时,ERROR 延后清理而不锁故障,FATAL 仍关链。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:两者最终都释放写资源。
*/
static void test_stop_send_exception(void)
{
uint8_t bytes[249];unsigned fault;
for(fault=4;fault<=5;++fault) {
open_fs();send_fs(bytes,activation(bytes,true,4,0,false));fs.high_fault=fault;
CHECK(execute()==IEC104_FILE_SERVICE_EXECUTE_OK);
CHECK(status().faulted==(fault==5));CHECK(fs.closes==(fault==5?1U:0U));
fs.high_fault=0;events();CHECK(execute()==IEC104_FILE_SERVICE_EXECUTE_OK);CHECK(fs.calls[7]==1);close_fs();
}
}
/**
* 功能:验证以下场景与约束:同地址站点替换后旧段不得写入新站,清理保留原站身份。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:同时在写和目录回调中验证重入保护。
*/
static void test_station_identity_and_reentry(void)
{
uint8_t bytes[249],data[]={1,2};uint64_t old_id;
open_fs();fs.reenter=true;activate_write(2,1,false);old_id=fs.last.station_id;
CHECK(IEC104_Slave_Remove_Station(fs.slave,&fs.stations[0])==IEC104_STATION_OK);
CHECK(!IEC104_Station_Is_Reusable(&fs.stations[0]));
CHECK(IEC104_Slave_Add_Station(fs.slave,&fs.stations[2],1,&fs)==IEC104_STATION_OK);
send_fs(bytes,segment(bytes,1,0,data,2,false,false));CHECK(execute()==IEC104_FILE_SERVICE_EXECUTE_OK);
CHECK(fs.writes==0 && status().stray_segments==1);
IEC104_FileService_Cancel(fs.module);CHECK(execute()==IEC104_FILE_SERVICE_EXECUTE_OK);
CHECK(fs.last.station_id==old_id && IEC104_Station_Is_Reusable(&fs.stations[0]));close_fs();
open_fs();fs.reenter=true;send_fs(bytes,directory(bytes,5,false));settle();CHECK(fs.calls[2]==1);close_fs();
}
/**
* 功能:验证关闭读、写或目录功能后请求收到拒绝且不调用业务回调,禁用写入时数据段不进入段队列。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。
*/
static void test_feature_gates(void)
{
IEC104_FileServiceConfig_t config;uint8_t bytes[249],data[]={1,2};
IEC104_FileService_Config_Default(&config);config.features=IEC104_FILE_SERVICE_FEATURE_DIRECTORY;
open_config(&config);send_fs(bytes,activation(bytes,false,0,0,false));settle();result(0,4,1);
send_fs(bytes,activation(bytes,true,2,0,false));settle();result(1,8,1);
send_fs(bytes,segment(bytes,0,0,data,2,false,false));CHECK(status().stray_segments==1 && status().pending_segments==0);close_fs();
config.features=IEC104_FILE_SERVICE_FEATURE_WRITE;open_config(&config);
send_fs(bytes,directory(bytes,5,false));settle();result(0,2,1);CHECK(fs.calls[1]==0);close_fs();
}
/**
* 功能:验证底层状态查询失败时输出快照逐字节保持不变,恢复查询后模块也未因此进入故障态。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。
*/
static void test_status_failure_preserves_output(void)
{
IEC104_FileServiceStatus_t value,before;
open_fs();memset(&value,0x5a,sizeof(value));before=value;fs.query_fault=1;
CHECK(!IEC104_FileService_Get_Status(fs.module,&value) && memcmp(&value,&before,sizeof(value))==0);
fs.query_fault=0;CHECK(!status().faulted);close_fs();
}
/**
* 功能:验证发送受阻时读数据等待且不调用 read。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:预留窗口非法时拒绝文件读取,但目录召唤仍可完成。
*/
static void test_idle_priority_and_reserve(void)
{
IEC104_FileServiceConfig_t config;uint8_t bytes[249];
open_fs();fake.send_blocked=1;
send_fs(bytes,activation(bytes,false,0,0,false));CHECK(execute()==IEC104_FILE_SERVICE_EXECUTE_OK);
CHECK(execute()==IEC104_FILE_SERVICE_EXECUTE_WAIT && fs.reads==0);
fake.send_blocked=0;settle();CHECK(status().reads_completed==1);close_fs();
IEC104_FileService_Config_Default(&config);config.window_reserve=32;open_config(&config);
CHECK(status().reserve_invalid);send_fs(bytes,activation(bytes,false,0,0,false));settle();result(0,4,1);CHECK(fs.calls[3]==0);
send_fs(bytes,directory(bytes,5,false));settle();result(1,2,0);close_fs();
}
/**
* 功能:逐段确认队列满时允许丢弃中间确认,验证最终确认仍保留、业务只提交一次并记录丢弃数量。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:检查不满足时由 CHECK 立即报告失败,不继续本用例。
*/
static void test_each_confirm_overflow(void)
{
IEC104_FileServiceConfig_t config;uint8_t bytes[249],data[]={1,2};unsigned i;
IEC104_FileService_Config_Default(&config);config.write_confirm_mode=IEC104_FILE_SERVICE_WRITE_CONFIRM_EACH;
open_config(&config);activate_write(10,1,false);fs.high_fault=1;
for(i=0;i<5;++i) { send_fs(bytes,segment(bytes,1,i*2,data,2,i!=4,false));CHECK(execute()==IEC104_FILE_SERVICE_EXECUTE_OK); }
CHECK(status().pending_replies==2 && status().dropped_replies==3 && status().finish_pending);
CHECK(execute()==IEC104_FILE_SERVICE_EXECUTE_OK);CHECK(fs.calls[5]==1 && status().pending_replies==2);
fs.high_fault=0;settle();CHECK(fs.record_count==3 && le32(fs.records[2]+15)==8);result(2,10,0);close_fs();
}
/**
* 功能:验证以下场景与约束:真正填满k窗口,使op4得到非零PENDING票据。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:即使IDLE预检可过,也不能提前调用read。
* DATA不得执行OPEN,CONTROL不得偷偷读数据;末段后的CLOSE仍交CONTROL。
*/
static void test_read_control_data_dependency(void)
{
uint8_t bytes[249], init_bytes[10]={70,1,4,0,1,0,0,0,0,0};
IEC60870_Asdu_t init;
IEC104_SlaveEventIdentity_t identity;
unsigned i;
open_fs();fs.read_size=3;
send_fs(bytes,activation(bytes,false,0,0,false));
CHECK(IEC104_FileService_Execute_Next_Mode(fs.module,&handlers,&fs,
IEC104_FILE_SERVICE_EXECUTE_DATA)==IEC104_FILE_SERVICE_EXECUTE_EMPTY);
CHECK(fs.calls[IEC104_FILE_SERVICE_CALL_OPEN_READ]==0 && fs.reads==0);
CHECK(IEC104_Slave_Get_Event_Identity(fs.slave,&fs.input,&identity));
CHECK(IEC60870_Asdu_Create_From_Buffer(&init,IEC104_Slave_Get_Application_Layer_Parameters(fs.slave),
init_bytes,sizeof(init_bytes))==IEC60870_ASDU_OK);
for(i=0;i<32U;++i)CHECK(IEC104_Slave_Send_Response(fs.slave,&identity,&init)==IEC104_TCP_SUBMIT_OK);
CHECK(IEC104_FileService_Execute_Next_Mode(fs.module,&handlers,&fs,
IEC104_FILE_SERVICE_EXECUTE_CONTROL)==IEC104_FILE_SERVICE_EXECUTE_OK);
CHECK(fs.record_count==1 && fs.records[0][10]==4 && fs.last_response_ticket!=0U);
CHECK(IEC104_Slave_Get_Response_State(fs.slave,fs.last_response_ticket)==IEC104_RESPONSE_PENDING);
fs.idle_fault=11U;
CHECK(IEC104_FileService_Execute_Next_Mode(fs.module,&handlers,&fs,
IEC104_FILE_SERVICE_EXECUTE_DATA)==IEC104_FILE_SERVICE_EXECUTE_WAIT);
CHECK(fs.reads==0 && fs.record_count==1);
fs.idle_fault=0;flush();
CHECK(IEC104_Slave_Get_Response_State(fs.slave,fs.last_response_ticket)==IEC104_RESPONSE_HANDED);
CHECK(IEC104_FileService_Execute_Next_Mode(fs.module,&handlers,&fs,
IEC104_FILE_SERVICE_EXECUTE_CONTROL)==IEC104_FILE_SERVICE_EXECUTE_EMPTY);
CHECK(fs.reads==0);
CHECK(IEC104_FileService_Execute_Next_Mode(fs.module,&handlers,&fs,
IEC104_FILE_SERVICE_EXECUTE_DATA)==IEC104_FILE_SERVICE_EXECUTE_OK);
CHECK(fs.reads==1 && fs.record_count==2 && fs.records[1][10]==5 && fs.record_idle[1]);
CHECK(IEC104_FileService_Execute_Next_Mode(fs.module,&handlers,&fs,
IEC104_FILE_SERVICE_EXECUTE_DATA)==IEC104_FILE_SERVICE_EXECUTE_EMPTY);
CHECK(IEC104_FileService_Execute_Next_Mode(fs.module,&handlers,&fs,
IEC104_FILE_SERVICE_EXECUTE_CONTROL)==IEC104_FILE_SERVICE_EXECUTE_OK);
CHECK(fs.calls[IEC104_FILE_SERVICE_CALL_CLOSE_READ]==1);close_fs();
}
/**
* 功能:验证以下场景与约束:精确最坏路径:四个旧资源清理 + 新零长度OPEN + COMMIT + 消费一个环头。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:被保留事件是最后一条通知,因此COMMIT可READY;这使7步而非更短路径真正发生。
*/
static void test_busy_seven_step_bound(void)
{
uint8_t bytes[249],data[]={1,2};unsigned i,before;
open_fs();activate_read(false);
send_fs(bytes,directory(bytes,5,false));CHECK(execute()==IEC104_FILE_SERVICE_EXECUTE_OK);
CHECK(fs.directory_resources==1 && fs.read_resources==1);
activate_write(2,1,false);fs.check_fault=2;
send_fs(bytes,segment(bytes,1,0,data,2,false,false));CHECK(execute()==IEC104_FILE_SERVICE_EXECUTE_OK);
send_fs(bytes,activation(bytes,true,2,2,false));CHECK(execute()==IEC104_FILE_SERVICE_EXECUTE_OK);
send_fs(bytes,segment(bytes,2,0,data,2,false,false));CHECK(execute()==IEC104_FILE_SERVICE_EXECUTE_OK);
CHECK(fs.resources==4 && fs.calls[5]==0);
IEC104_FileService_Cancel(fs.module);fs.check_fault=0;
send_fs(bytes,activation(bytes,true,0,3,false));
for(i=0;i<IEC104_FILE_SERVICE_SEGMENT_CAPACITY;++i)send_fs(bytes,segment(bytes,3,0,NULL,0,false,false));
CHECK(status().segments_full);before=fs.busy_steps;
send_fs(bytes,segment(bytes,3,0,NULL,0,false,false));
CHECK(fs.busy_steps-before==IEC104_FILE_SERVICE_BUSY_STEP_LIMIT);
CHECK(fs.calls[2]==1 && fs.calls[6]==1 && fs.calls[7]==2 && fs.calls[5]==1 && fs.resources==0);
settle();close_fs();
}
/**
* 功能:逐项破坏 STOP 例外状态条件,验证均转为发送故障。
* 输入参数:无。
* 输出参数:无。
* 返回值:无。
* 说明:IDLE 准入和提交不适用 HIGH 确认的 STOP 例外。
*/
static void test_stop_predicate_negations(void)
{
uint8_t bytes[249];unsigned poison,mode;
/* 除身份(内部边界专项)外,对每项状态谓词逐个造反例,其他谓词仍为真实STOP。 */
for(poison=1;poison<=9;++poison) {
open_fs();send_fs(bytes,activation(bytes,true,4,0,false));fs.high_fault=4;fs.stop_status_poison=poison;
CHECK(execute()==IEC104_FILE_SERVICE_EXECUTE_OK);fs.stop_observed=false;
CHECK(status().faulted && fs.closes==1 && status().send_errors==1);
close_fs();
}
/* IDLE准入/提交即使恰遇未分派STOP,也不能借HIGH的ERROR例外继续保留会话。 */
for(mode=7;mode<=10;++mode) {
open_fs();activate_read(false);fs.idle_fault=mode;
CHECK(execute()==(mode<=8?IEC104_FILE_SERVICE_EXECUTE_ERROR:IEC104_FILE_SERVICE_EXECUTE_OK));
CHECK(status().faulted && fs.closes==1);close_fs();
}
}
/**
* 功能:执行文件服务协议、资源生命周期和故障边界各组用例,输出通过组数及当前容量配置。
* 输入参数:无。
* 输出参数:无。
* 返回值:正常完成返回 0;参数、运行或断言失败以非零状态结束进程。
* 说明:本辅助入口用于构造或核对上述测试场景,相关状态保存在当前测试夹具中。
*/
int main(void)
{
#define RUN(fn) do { ++groups; fn(); } while(0)
RUN(test_configuration);RUN(test_wire_validation);RUN(test_lengths_and_names);RUN(test_maximum_names);
RUN(test_directory_vectors);RUN(test_directory_frames_and_wait);RUN(test_directory_budget_filter);RUN(test_directory_lookahead);
RUN(test_directory_output_errors);RUN(test_time_validation);RUN(test_read_vectors);RUN(test_read_stream_wait_abort);
RUN(test_read_confirm_modes);RUN(test_read_open_failure_and_test);RUN(test_write_vectors);RUN(test_write_errors);
RUN(test_write_modes_and_commit_failure);RUN(test_write_open_results);RUN(test_busy_pipeline);RUN(test_commit_wait_and_order);
RUN(test_commit_stop_and_cancel);RUN(test_empty_pending_merge);RUN(test_test_isolation);RUN(test_supersession_and_full);
RUN(test_silent_cancel_marker);RUN(test_write_expiry);RUN(test_directory_read_deadlines);RUN(test_reply_and_reserved_deadlines);
RUN(test_faults_after_and_before_callbacks);RUN(test_stop_send_exception);RUN(test_station_identity_and_reentry);
RUN(test_feature_gates);RUN(test_status_failure_preserves_output);RUN(test_idle_priority_and_reserve);RUN(test_each_confirm_overflow);
RUN(test_busy_seven_step_bound);RUN(test_stop_predicate_negations);RUN(test_read_control_data_dependency);
#undef RUN
printf("FileService: %u groups passed (TCP=%u tasks=%u segments=%u)\n",groups,
(unsigned)IEC104_TCP_SERVER_CAPACITY,(unsigned)IEC104_FILE_SERVICE_TASK_CAPACITY,(unsigned)IEC104_FILE_SERVICE_SEGMENT_CAPACITY);
return 0;
}