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

489 lines
25 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.
/* Type42独立字节向量、扩展布局、截短/尾随拒绝及失败原子性测试。
* 测试不使用网络、系统时钟或真实主站程序;格式依据已确认的接收端解析行为。
* 手工原文与固定偏移断言是格式检查的独立依据;Parse/Getter另行验证视图与逐条读取契约。
* 文件内导航:
* [CODEC/FIXTURE] 公共头、冻结值及失败输出哨兵。
* [CODEC/GOLDEN] 固定字节、借用ASDU边界及全部256种VSQ。
* [CODEC/MATRIX] CA/COT/IOA宽度与内部类型的144种组合。
* [CODEC/INVALID] 截短、尾随、字段突变及编码失败原子性。
* [CODEC/LIMIT] 公共空结构、容量上限及Getter输出保护。
* [ENTRY] 六组主机测试入口。 */
#include "IEC60870_FaultEvent.h"
#include <math.h>
#include <stdio.h>
#include <string.h>
#define CHECK(condition) do { if (!(condition)) { \
fprintf(stderr, "FAIL %s:%d: %s\n", __FILE__, __LINE__, #condition); return 0; \
} } while (0)
/* [CODEC/FIXTURE] 35字节手工ASDU,不包含APCI:偏移0..5为公共头,6/7为N=1/type=30,
* 8..10为3字节IOA,11为SIQ,12..18为2026-11-12 13:14:15.016的CP56(不带星期)。
* 偏移19/20为M=2/type=13,随后两项各占3字节地址+4字节float;-1.5/230.5没有QDS。
* 数量少于业务要求的8项是有意的:这里只验证公共格式,不验证故障电气量是否齐全。 */
static const uint8_t golden[] = {
0x2A, 0x01, 0x03, 0x07, 0x34, 0x12,
0x01, 0x1E,
0x56, 0x34, 0x12, 0x01, 0xA8, 0x3A, 0x0E, 0x0D, 0x0C, 0x0B, 0x1A,
0x02, 0x0D,
0x01, 0x40, 0x00, 0x00, 0x00, 0xC0, 0xBF,
0x02, 0x40, 0x00, 0x00, 0x80, 0x66, 0x43
};
/**
* 功能:以104常用的COT/CA/IOA=2/2/3及249字节上限为起点。
* 输入参数:无。
* 输出参数:无。
* 返回值:本组测试使用的配置值副本。
* 说明:宽度矩阵会按值修改副本。
*/
static IEC60870_AppLayerParameters_t Parameters(void)
{
IEC60870_AppLayerParameters_t p = {1, 1, 2, 0, 2, 3, 249};
return p;
}
/**
* 功能:明确OA=7、CA=0x1234,便于从固定字节发现公共头错位。
* 输入参数:无。
* 输出参数:无。
* 返回值:按测试样本构造的 ASDU 公共头。
* 说明:P/N与TEST默认为0。
*/
static IEC60870_AsduHeader_t Header(void)
{
IEC60870_AsduHeader_t header;
memset(&header, 0, sizeof(header));
header.cause_of_transmission = IEC60870_ASDU_COT_SPONTANEOUS;
header.originator_address = 7U;
header.common_address = 0x1234U;
return header;
}
/**
* 功能:每次重建相同的调用方快照,指针只绑定到调用方传入的存储。
* 输入参数:event——业务或传输事件;signal——故障信号存储;measurements——故障遥测数组。
* 输出参数:event——业务或传输事件;signal——故障信号存储;measurements——故障遥测数组。
* 返回值:无。
* 说明:时间不来自当前系统。
* 第二项遥测用于验证错误落在合法前缀之后时,编码器仍不得先写出前缀。
*/
static void Fixture(IEC60870_FaultEvent_t *event,
IEC60870_FaultEventSignal_t *signal, IEC60870_FaultEventMeasurement_t *measurements)
{
IEC60870_FaultEvent_Init(event);
memset(signal, 0, sizeof(*signal));
signal->ioa = 0x123456U;
signal->value = 1U;
signal->timestamp.time.year = 2026U;
signal->timestamp.time.month = 11U;
signal->timestamp.time.day = 12U;
signal->timestamp.time.hour = 13U;
signal->timestamp.time.minute = 14U;
signal->timestamp.time.second = 15U;
signal->timestamp.time.ms = 16U;
memset(measurements, 0, 2U * sizeof(*measurements));
measurements[0].ioa = 0x4001U;
measurements[0].value.short_float = -1.5f;
measurements[1].ioa = 0x4002U;
measurements[1].value.short_float = 230.5f;
event->signals = signal;
event->signal_count = 1U;
event->measurements = measurements;
event->measurement_count = 2U;
}
/**
* 功能:解析失败必须保持整个视图(含填充字节)不变,不能留下新的头或旧的半组索引。
* 输入参数:parameters——应用层字段宽度配置(只读);bytes——报文字节缓冲区(只读);length——字节长度。
* 输出参数:无。
* 返回值:非零表示本次操作或检查通过;0 表示失败。
* 说明:检查不满足时由 CHECK 立即返回失败,不继续后续断言。
*/
static int Reject_Parse(const IEC60870_AppLayerParameters_t *parameters,
const uint8_t *bytes, uint16_t length)
{
IEC60870_FaultEventView_t view, before;
memset(&view, 0xA5, sizeof(view));
memcpy(&before, &view, sizeof(before));
CHECK(IEC60870_FaultEvent_Parse(parameters, bytes, length, &view) == IEC60870_ASDU_ERROR);
CHECK(memcmp(&view, &before, sizeof(view)) == 0);
return 1;
}
/**
* 功能:同时保护输出长度和整个目标缓冲:FULL与ERROR均不允许提交公共头或部分记录。
* 输入参数:parameters——应用层字段宽度配置(只读);header——ASDU 公共头(只读);event——业务或传输事件(只读);capacity——调用方提供的缓冲容量;expected——期望的结果或数量。
* 输出参数:无。
* 返回值:非零表示本次操作或检查通过;0 表示失败。
* 说明:检查范围包含capacity之外的哨兵,亦能发现容量错误导致的越界写。
*/
static int Reject_Encode(const IEC60870_AppLayerParameters_t *parameters,
const IEC60870_AsduHeader_t *header, const IEC60870_FaultEvent_t *event,
uint16_t capacity, IEC60870_AsduResult_t expected)
{
uint8_t bytes[256], before[256];
uint16_t length = 0xA55AU;
memset(bytes, 0xA5, sizeof(bytes));
memcpy(before, bytes, sizeof(before));
CHECK(IEC60870_FaultEvent_Encode(parameters, header, event, bytes, capacity, &length) == expected);
CHECK(length == 0xA55AU && memcmp(bytes, before, sizeof(bytes)) == 0);
return 1;
}
/**
* 功能:验证以下场景与约束:[CODEC/GOLDEN] 先与手工字节逐一核对,再检查借用视图和Getter读取。
* 输入参数:无。
* 输出参数:无。
* 返回值:非零表示本次操作或检查通过;0 表示失败。
* 说明:精确容量后的字节须不变。
*/
static int Test_Golden(void)
{
IEC60870_AppLayerParameters_t p = Parameters();
IEC60870_AsduHeader_t h = Header();
IEC60870_FaultEvent_t event;
IEC60870_FaultEventSignal_t signal, decoded_signal;
IEC60870_FaultEventMeasurement_t measurements[2], decoded_measurement;
IEC60870_FaultEventView_t view;
IEC60870_AsduInfo_t ordinary;
IEC60870_Asdu_t borrowed;
uint8_t bytes[256];
uint16_t length = 0U;
unsigned int vsq;
Fixture(&event, &signal, measurements);
memset(bytes, 0xA5, sizeof(bytes));
CHECK(IEC60870_FaultEvent_Encode(&p, &h, &event, bytes, sizeof(golden), &length) == IEC60870_ASDU_OK);
CHECK(length == sizeof(golden) && memcmp(bytes, golden, sizeof(golden)) == 0);
CHECK(bytes[sizeof(golden)] == 0xA5U);
CHECK(IEC60870_FaultEvent_Parse(&p, bytes, length, &view) == IEC60870_ASDU_OK);
CHECK(view.asdu == bytes && view.parameters == &p && view.length == sizeof(golden));
CHECK(view.signal_count == 1U && view.signal_type == 30U);
CHECK(view.measurement_count == 2U && view.measurement_type == 13U);
CHECK(view.header.common_address == 0x1234U && view.header.originator_address == 7U);
CHECK(IEC60870_FaultEvent_Get_Signal(&view, 0U, &decoded_signal) == IEC60870_ASDU_OK);
CHECK(decoded_signal.ioa == signal.ioa && decoded_signal.value == signal.value);
CHECK(decoded_signal.timestamp.time.year == 2026U && decoded_signal.timestamp.time.month == 11U);
CHECK(decoded_signal.timestamp.time.day == 12U && decoded_signal.timestamp.time.hour == 13U);
CHECK(decoded_signal.timestamp.time.minute == 14U && decoded_signal.timestamp.time.second == 15U);
CHECK(decoded_signal.timestamp.time.ms == 16U && decoded_signal.timestamp.has_weekday == 0U);
CHECK(IEC60870_FaultEvent_Get_Measurement(&view, 0U, &decoded_measurement) == IEC60870_ASDU_OK);
CHECK(decoded_measurement.ioa == 0x4001U && decoded_measurement.value.short_float == -1.5f);
CHECK(IEC60870_FaultEvent_Get_Measurement(&view, 1U, &decoded_measurement) == IEC60870_ASDU_OK);
CHECK(decoded_measurement.ioa == 0x4002U && decoded_measurement.value.short_float == 230.5f);
/* 可以借用完整ASDU交接发送,但普通对象解析器不能错误地解释此异构结构。 */
CHECK(IEC60870_Asdu_Create_From_Buffer(&borrowed, &p, bytes, length) == IEC60870_ASDU_OK);
CHECK(IEC60870_Asdu_Parse(&p, bytes, length, &ordinary) == IEC60870_ASDU_UNSUPPORTED);
/* Type42数量取报文体;穷举VSQ的低7位和SQ位,确认任何取值都不改变N/M定位。 */
for (vsq = 0U; vsq <= 255U; ++vsq) {
bytes[1] = (uint8_t)vsq;
CHECK(IEC60870_FaultEvent_Parse(&p, bytes, length, &view) == IEC60870_ASDU_OK);
CHECK(view.signal_count == 1U && view.measurement_count == 2U);
}
return 1;
}
/**
* 功能:验证以下场景与约束:[CODEC/MATRIX] 2种CA宽度*2种COT宽度*3种共用IOA宽度*4种遥信类型*3种遥测类型=144组。
* 输入参数:无。
* 输出参数:无。
* 返回值:非零表示本次操作或检查通过;0 表示失败。
* 说明:同一IOA宽度必须同时用于两组记录;TEST、SIQ/DIQ品质、CP56的IV/SU均独立保留。
* 2字节遥测按原码验证65535,避免测试本身先把无符号原码解释成负数。
*/
static int Test_Width_And_Type_Matrix(void)
{
static const uint8_t signals[] = {1U, 3U, 30U, 31U};
static const uint8_t measurements[] = {9U, 11U, 13U};
IEC60870_AppLayerParameters_t p = Parameters();
IEC60870_AsduHeader_t h = Header();
IEC60870_FaultEvent_t event;
IEC60870_FaultEventSignal_t signal, decoded_signal;
IEC60870_FaultEventMeasurement_t values[2], decoded_measurement;
IEC60870_FaultEventView_t view;
uint8_t bytes[256];
uint16_t length;
size_t i, j;
int ca, cot, ioa;
for (ca = 1; ca <= 2; ++ca) {
for (cot = 1; cot <= 2; ++cot) {
for (ioa = 1; ioa <= 3; ++ioa) {
p.sizeOfCA = ca;
p.sizeOfCOT = cot;
p.sizeOfIOA = ioa;
h.common_address = ca == 1 ? 0x34U : 0x1234U;
h.is_test = 1U;
for (i = 0U; i < sizeof(signals); ++i) {
for (j = 0U; j < sizeof(measurements); ++j) {
size_t head = (size_t)(2 + ca + cot), analog;
unsigned int value_size = measurements[j] == 13U ? 4U : 2U;
Fixture(&event, &signal, values);
event.signal_type = signals[i];
event.measurement_type = measurements[j];
signal.ioa = (UINT32_C(1) << (8U * (unsigned int)ioa)) - 1U;
signal.value = (signals[i] == 1U || signals[i] == 30U) ? 0xF1U : 0xF3U;
signal.timestamp.is_invalid = 1U;
signal.timestamp.is_summer_time = 1U;
/* 公共编解码接受可表示的零地址;是否允许作为业务点号由上送入口判断。 */
values[0].ioa = 0U;
values[1].ioa = signal.ioa;
if (value_size == 2U) {
values[0].value.unsigned_value = 0xFFFFU;
values[1].value.unsigned_value = 0x8000U;
}
CHECK(IEC60870_FaultEvent_Encode(&p, &h, &event, bytes, sizeof(bytes), &length) == IEC60870_ASDU_OK);
CHECK(length == head + 4U + (size_t)ioa + 8U + 2U * ((size_t)ioa + value_size));
CHECK(bytes[2] == 0x83U && bytes[head] == 1U && bytes[head + 1U] == signals[i]);
CHECK(bytes[head + 2U] == 0xFFU);
if (ioa >= 2) { CHECK(bytes[head + 3U] == 0xFFU); }
if (ioa == 3) { CHECK(bytes[head + 4U] == 0xFFU); }
/* 一个遥信项为IOA+SIQ/DIQ+7字节时标,不能把其类型1/3误作无时标格式。 */
analog = head + 2U + (size_t)ioa + 8U;
CHECK(bytes[analog] == 2U && bytes[analog + 1U] == measurements[j]);
if (value_size == 2U) {
CHECK(bytes[analog + 2U + (size_t)ioa] == 0xFFU);
CHECK(bytes[analog + 3U + (size_t)ioa] == 0xFFU);
}
CHECK(IEC60870_FaultEvent_Parse(&p, bytes, length, &view) == IEC60870_ASDU_OK);
CHECK(view.header.is_test == 1U && view.header.originator_address == (cot == 1 ? 0U : 7U));
CHECK(IEC60870_FaultEvent_Get_Signal(&view, 0U, &decoded_signal) == IEC60870_ASDU_OK);
CHECK(decoded_signal.ioa == signal.ioa && decoded_signal.value == signal.value);
CHECK(decoded_signal.timestamp.is_invalid == 1U && decoded_signal.timestamp.is_summer_time == 1U);
CHECK(IEC60870_FaultEvent_Get_Measurement(&view, 0U, &decoded_measurement) == IEC60870_ASDU_OK);
if (value_size == 2U) { CHECK(decoded_measurement.value.unsigned_value == 65535U); }
else { CHECK(decoded_measurement.value.short_float == -1.5f); }
}
}
}
}
}
return 1;
}
/**
* 功能:验证以下场景与约束:[CODEC/INVALID] 对固定报文的每一个截短位置、额外尾字节及字段突变检查整帧拒绝。
* 输入参数:无。
* 输出参数:无。
* 返回值:非零表示本次操作或检查通过;0 表示失败。
* 说明:mutations分别破坏TI/COT/P-N、数量、内部类型、SIQ、日历及遥测数量;不靠缺字节掩盖值错误。
*/
static int Test_Invalid_Frames(void)
{
static const struct { size_t index; uint8_t value; } mutations[] = {
{0U, 41U}, {2U, 6U}, {2U, 0x43U}, {6U, 255U}, {7U, 2U},
{11U, 2U}, {16U, 0U}, {17U, 0U}, {18U, 100U},
{19U, 1U}, {19U, 3U}, {20U, 0U}, {20U, 36U}
};
IEC60870_AppLayerParameters_t p = Parameters();
uint8_t bytes[256];
size_t i;
for (i = 0U; i < sizeof(golden); ++i) { CHECK(Reject_Parse(&p, golden, (uint16_t)i)); }
memcpy(bytes, golden, sizeof(golden));
bytes[sizeof(golden)] = 0U;
CHECK(Reject_Parse(&p, bytes, (uint16_t)(sizeof(golden) + 1U)));
for (i = 0U; i < sizeof(mutations) / sizeof(mutations[0]); ++i) {
memcpy(bytes, golden, sizeof(golden));
bytes[mutations[i].index] = mutations[i].value;
CHECK(Reject_Parse(&p, bytes, sizeof(golden)));
}
memcpy(bytes, golden, sizeof(golden));
/* 24..27为首项float本体;直接写IEEE 754位模式,避免宿主浮点运算改变测试输入。 */
bytes[24] = 0U; bytes[25] = 0U; bytes[26] = 0x80U; bytes[27] = 0x7FU;
CHECK(Reject_Parse(&p, bytes, sizeof(golden))); /* +Inf */
bytes[26] = 0xC0U;
CHECK(Reject_Parse(&p, bytes, sizeof(golden))); /* NaN */
CHECK(Reject_Parse(&p, NULL, sizeof(golden)));
CHECK(Reject_Parse(NULL, golden, sizeof(golden)));
p.maxSizeOfASDU = (int)sizeof(golden) - 1;
CHECK(Reject_Parse(&p, golden, sizeof(golden)));
p = Parameters();
p.sizeOfIOA = 4;
CHECK(Reject_Parse(&p, golden, sizeof(golden)));
CHECK(IEC60870_FaultEvent_Parse(&p, golden, sizeof(golden), NULL) == IEC60870_ASDU_ERROR);
return 1;
}
/**
* 功能:验证以下场景与约束:构造端分别覆盖空间不足、配置非法和内容非法。
* 输入参数:无。
* 输出参数:无。
* 返回值:非零表示本次操作或检查通过;0 表示失败。
* 说明:修改靠后的测量验证“全量检查后写出”。
* SIZE_MAX数量必须在遍历数组之前拒绝,不能截窄成1字节后继续编码。
*/
static int Test_Encode_Failures(void)
{
IEC60870_AppLayerParameters_t p = Parameters();
IEC60870_AsduHeader_t h = Header();
IEC60870_FaultEvent_t event;
IEC60870_FaultEventSignal_t signal;
IEC60870_FaultEventMeasurement_t values[2];
uint8_t bytes[256];
uint16_t length = 99U;
unsigned int capacity;
Fixture(&event, &signal, values);
for (capacity = 0U; capacity < sizeof(golden); ++capacity) {
CHECK(Reject_Encode(&p, &h, &event, (uint16_t)capacity, IEC60870_ASDU_FULL));
}
p.maxSizeOfASDU = (int)sizeof(golden) - 1;
CHECK(Reject_Encode(&p, &h, &event, sizeof(bytes), IEC60870_ASDU_FULL));
p = Parameters();
CHECK(Reject_Encode(NULL, &h, &event, sizeof(bytes), IEC60870_ASDU_ERROR));
CHECK(Reject_Encode(&p, NULL, &event, sizeof(bytes), IEC60870_ASDU_ERROR));
CHECK(Reject_Encode(&p, &h, NULL, sizeof(bytes), IEC60870_ASDU_ERROR));
h.cause_of_transmission = 6U;
CHECK(Reject_Encode(&p, &h, &event, sizeof(bytes), IEC60870_ASDU_ERROR));
h = Header(); h.is_negative_confirm = 1U;
CHECK(Reject_Encode(&p, &h, &event, sizeof(bytes), IEC60870_ASDU_ERROR));
h = Header(); h.is_test = 2U;
CHECK(Reject_Encode(&p, &h, &event, sizeof(bytes), IEC60870_ASDU_ERROR));
h = Header(); p.sizeOfCA = 1;
CHECK(Reject_Encode(&p, &h, &event, sizeof(bytes), IEC60870_ASDU_ERROR));
p = Parameters(); event.signal_count = 256U;
CHECK(Reject_Encode(&p, &h, &event, sizeof(bytes), IEC60870_ASDU_ERROR));
event.signal_count = SIZE_MAX;
CHECK(Reject_Encode(&p, &h, &event, sizeof(bytes), IEC60870_ASDU_ERROR));
event.signal_count = 1U; event.measurement_count = SIZE_MAX;
CHECK(Reject_Encode(&p, &h, &event, sizeof(bytes), IEC60870_ASDU_ERROR));
event.measurement_count = 2U; event.signals = NULL;
CHECK(Reject_Encode(&p, &h, &event, sizeof(bytes), IEC60870_ASDU_ERROR));
event.signals = &signal; event.measurements = NULL;
CHECK(Reject_Encode(&p, &h, &event, sizeof(bytes), IEC60870_ASDU_ERROR));
event.measurements = values; event.signal_type = 2U;
CHECK(Reject_Encode(&p, &h, &event, sizeof(bytes), IEC60870_ASDU_ERROR));
event.signal_type = 30U; event.measurement_type = 36U;
CHECK(Reject_Encode(&p, &h, &event, sizeof(bytes), IEC60870_ASDU_ERROR));
event.measurement_type = 13U; signal.value = 2U;
CHECK(Reject_Encode(&p, &h, &event, sizeof(bytes), IEC60870_ASDU_ERROR));
event.signal_type = 31U; signal.value = 4U;
CHECK(Reject_Encode(&p, &h, &event, sizeof(bytes), IEC60870_ASDU_ERROR));
signal.value = 1U; signal.ioa = 0x1000000U;
CHECK(Reject_Encode(&p, &h, &event, sizeof(bytes), IEC60870_ASDU_ERROR));
signal.ioa = 0x123456U; signal.timestamp.time.day = 31U;
CHECK(Reject_Encode(&p, &h, &event, sizeof(bytes), IEC60870_ASDU_ERROR));
signal.timestamp.time.day = 12U; signal.timestamp.is_invalid = 2U;
CHECK(Reject_Encode(&p, &h, &event, sizeof(bytes), IEC60870_ASDU_ERROR));
signal.timestamp.is_invalid = 0U; values[1].ioa = 0x1000000U;
CHECK(Reject_Encode(&p, &h, &event, sizeof(bytes), IEC60870_ASDU_ERROR));
values[1].ioa = 0x4002U; values[1].value.short_float = INFINITY;
CHECK(Reject_Encode(&p, &h, &event, sizeof(bytes), IEC60870_ASDU_ERROR));
values[1].value.short_float = -INFINITY;
CHECK(Reject_Encode(&p, &h, &event, sizeof(bytes), IEC60870_ASDU_ERROR));
values[1].value.short_float = NAN;
CHECK(Reject_Encode(&p, &h, &event, sizeof(bytes), IEC60870_ASDU_ERROR));
Fixture(&event, &signal, values);
p.sizeOfIOA = 2;
CHECK(Reject_Encode(&p, &h, &event, sizeof(bytes), IEC60870_ASDU_ERROR));
signal.ioa = 1U; values[1].ioa = 0x10000U;
CHECK(Reject_Encode(&p, &h, &event, sizeof(bytes), IEC60870_ASDU_ERROR));
p.sizeOfIOA = 1; values[0].ioa = 1U; values[1].ioa = 256U;
CHECK(Reject_Encode(&p, &h, &event, sizeof(bytes), IEC60870_ASDU_ERROR));
p.sizeOfIOA = 0;
CHECK(Reject_Encode(&p, &h, &event, sizeof(bytes), IEC60870_ASDU_ERROR));
p = Parameters();
CHECK(IEC60870_FaultEvent_Encode(&p, &h, &event, NULL, sizeof(bytes), &length) == IEC60870_ASDU_ERROR);
CHECK(length == 99U);
memset(bytes, 0xA5, sizeof(bytes));
CHECK(IEC60870_FaultEvent_Encode(&p, &h, &event, bytes, sizeof(bytes), NULL) == IEC60870_ASDU_ERROR);
CHECK(bytes[0] == 0xA5U && bytes[sizeof(bytes) - 1U] == 0xA5U);
return 1;
}
/**
* 功能:验证以下场景与约束:[CODEC/LIMIT] 公共层允许N=M=0的结构性空报文。
* 输入参数:无。
* 输出参数:无。
* 返回值:非零表示本次操作或检查通过;0 表示失败。
* 说明:它不等于104业务入口允许发布的故障报告。
* N=0、M=34时总长10+34*7=248;M=35超出249上限。数量255虽能放进字段,载荷仍必须整份适配。
*/
static int Test_Empty_And_Maximum(void)
{
IEC60870_AppLayerParameters_t p = Parameters();
IEC60870_AsduHeader_t h = Header();
IEC60870_FaultEvent_t event;
IEC60870_FaultEventMeasurement_t values[255];
IEC60870_FaultEventView_t view;
uint8_t bytes[256];
uint16_t length = 0U;
size_t i;
IEC60870_FaultEvent_Init(NULL);
memset(&event, 0xA5, sizeof(event));
IEC60870_FaultEvent_Init(&event);
CHECK(event.signal_type == 30U && event.measurement_type == 13U);
CHECK(event.signal_count == 0U && event.measurement_count == 0U);
CHECK(event.signals == NULL && event.measurements == NULL);
CHECK(IEC60870_FaultEvent_Encode(&p, &h, &event, bytes, sizeof(bytes), &length) == IEC60870_ASDU_OK);
CHECK(length == 10U && bytes[6] == 0U && bytes[7] == 30U && bytes[8] == 0U && bytes[9] == 13U);
CHECK(IEC60870_FaultEvent_Parse(&p, bytes, length, &view) == IEC60870_ASDU_OK);
CHECK(view.signal_count == 0U && view.measurement_count == 0U);
for (i = 0U; i < 255U; ++i) { values[i].ioa = (uint32_t)i; values[i].value.short_float = (float)i; }
event.measurements = values;
event.measurement_count = 34U;
CHECK(IEC60870_FaultEvent_Encode(&p, &h, &event, bytes, sizeof(bytes), &length) == IEC60870_ASDU_OK);
CHECK(length == 248U);
CHECK(IEC60870_FaultEvent_Parse(&p, bytes, length, &view) == IEC60870_ASDU_OK);
event.measurement_count = 35U;
CHECK(Reject_Encode(&p, &h, &event, sizeof(bytes), IEC60870_ASDU_FULL));
event.measurement_count = 255U;
CHECK(Reject_Encode(&p, &h, &event, sizeof(bytes), IEC60870_ASDU_FULL));
/* 合法数量255不允许靠输出长度截断为一个可发送的前缀。 */
return 1;
}
/**
* 功能:验证以下场景与约束:Getter的索引、指针和借用原文仍须有效。
* 输入参数:无。
* 输出参数:无。
* 返回值:非零表示本次操作或检查通过;0 表示失败。
* 说明:失败不能覆盖调用方上一条成功结果。
* 故意改坏已解析视图借用的数量字段,检查读取器会重新检查整帧,而非信任旧偏移。
*/
static int Test_Getter_Failures(void)
{
IEC60870_AppLayerParameters_t p = Parameters();
IEC60870_FaultEventView_t view;
IEC60870_FaultEventSignal_t signal, before_signal;
IEC60870_FaultEventMeasurement_t measurement, before_measurement;
uint8_t bytes[sizeof(golden)];
memcpy(bytes, golden, sizeof(bytes));
CHECK(IEC60870_FaultEvent_Parse(&p, bytes, sizeof(bytes), &view) == IEC60870_ASDU_OK);
memset(&signal, 0xA5, sizeof(signal));
memcpy(&before_signal, &signal, sizeof(signal));
memset(&measurement, 0xA5, sizeof(measurement));
memcpy(&before_measurement, &measurement, sizeof(measurement));
CHECK(IEC60870_FaultEvent_Get_Signal(&view, 1U, &signal) == IEC60870_ASDU_ERROR);
CHECK(IEC60870_FaultEvent_Get_Signal(&view, SIZE_MAX, &signal) == IEC60870_ASDU_ERROR);
CHECK(IEC60870_FaultEvent_Get_Signal(NULL, 0U, &signal) == IEC60870_ASDU_ERROR);
CHECK(IEC60870_FaultEvent_Get_Signal(&view, 0U, NULL) == IEC60870_ASDU_ERROR);
CHECK(IEC60870_FaultEvent_Get_Measurement(&view, 2U, &measurement) == IEC60870_ASDU_ERROR);
CHECK(IEC60870_FaultEvent_Get_Measurement(&view, SIZE_MAX, &measurement) == IEC60870_ASDU_ERROR);
CHECK(IEC60870_FaultEvent_Get_Measurement(NULL, 0U, &measurement) == IEC60870_ASDU_ERROR);
CHECK(IEC60870_FaultEvent_Get_Measurement(&view, 0U, NULL) == IEC60870_ASDU_ERROR);
CHECK(memcmp(&signal, &before_signal, sizeof(signal)) == 0);
CHECK(memcmp(&measurement, &before_measurement, sizeof(measurement)) == 0);
/* 遥测区被破坏后,读取前面看似完整的遥信也必须失败,不能交出半份故障事件。 */
bytes[19] = 255U;
CHECK(IEC60870_FaultEvent_Get_Signal(&view, 0U, &signal) == IEC60870_ASDU_ERROR);
CHECK(IEC60870_FaultEvent_Get_Measurement(&view, 0U, &measurement) == IEC60870_ASDU_ERROR);
CHECK(memcmp(&signal, &before_signal, sizeof(signal)) == 0);
CHECK(memcmp(&measurement, &before_measurement, sizeof(measurement)) == 0);
return 1;
}
/**
* 功能:[ENTRY] 每组立即传播失败。
* 输入参数:无。
* 输出参数:无。
* 返回值:正常完成返回 0;参数、运行或断言失败以非零状态结束进程。
* 说明:入口自身不改变参数、输出或主机时间。
*/
int main(void)
{
if (!Test_Golden() || !Test_Width_And_Type_Matrix() || !Test_Invalid_Frames() ||
!Test_Encode_Failures() || !Test_Empty_And_Maximum() || !Test_Getter_Failures()) { return 1; }
puts("iec60870_fault_event_test: PASS");
return 0;
}