1669 lines
86 KiB
C
1669 lines
86 KiB
C
/* 国网 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;
|
||
}
|
||
|
||
|