Files
STM32F4-Base/test/host/iec104_netmcu/netmcu_test.c
T
wandering1 c0cef2fca0 refactor(app): 去掉 App/protocol 层,104 迁入 App/iec60870/104_port
IEC 60870 是标准族(含 104/101),原 App/protocol/ 把它拆成
iec60870/(vendor 核心)+ iec104/(我方适配)两棵同级树,多一层且
看不出「104 只维护一个」。现按标准族收口:

  App/protocol/iec60870        -> App/iec60870
  App/protocol/iec104          -> App/iec60870/104_port
  App/protocol/{README.md,.gitkeep}  删除
  App/protocol/iec104/iec104_asdu.h  删除(零 include / 零注册的孤儿)

vendor 子树(104/ common/ examples/)逐字节未改:91 个 R100 重命名、
git diff --cached -M 后 0 insertions / 0 deletions,另按字节直比 89/89
一致;UPSTREAM.sha256 差异集仍等于既有 17 项受控差异,非篡改。
适配层只改注释里的路径字样,无逻辑行。

门禁配套:
- coding-standard 的 exclude 不能写祖先 App/iec60870/——rename_ref 机械
  改出的祖先形态会把 2,191 行适配层一起豁免掉。改为三条精确前缀
  common/ 104/ examples/,适配层 11/11 回到受检;vendor 直调脚本仍报
  88 处违规而钩子 Skipped,证明确实由 exclude 生效而非空跑。
- check_registration 的 KNOWN_GAPS 键与理由文本同步到新路径。

验证:Keil 0 errors 0 warnings(Code=367464 RO-data=48492
RW-data=2288 ZI-data=173544),构建日志与 .d 依赖证明 5 个适配 .o
真被编入;模拟器 0 警告并跑通 iec104-tcp 13/13 真实 TCP 回环;
pre-commit 25 Passed / 0 Failed;doc-links 30 处问题全在
IEC60870-Slave/ 供应商快照,我方文档零新增。

顺带删掉仓根误入库且零引用的 _all_hook.txt 与 _scope.txt。
2026-11-18 14:15:10 +08:00

514 lines
21 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.
/*
* IEC104 Net MCU backend isolation contract tests.
* Builds the REAL App/iec60870/104_port/iec104_net_mcu.c against a fake net layer.
* This is host-only evidence for the Net ABI, not full core/TcpServer or hardware.
*/
#include <stdio.h>
#include <string.h>
#include <stdint.h>
#include "IEC104_Net.h"
#include "net_socket_fake.h"
#ifndef NETMCU_BAD
#define NETMCU_BAD 0
#endif
static int failures;
static const char *current_case;
#define CHECK(cond, msg) do { \
if (!(cond)) { \
printf(" FAIL %s: %s\n", current_case, msg); \
++failures; \
} \
} while (0)
static IEC104_NetSocket_t setup_listen(uint16_t port)
{
IEC104_NetSocket_t listener = IEC104_NET_INVALID_SOCKET;
uint16_t bound = 0;
CHECK(IEC104_Net_Init(NULL) == IEC104_NET_OK, "Init");
CHECK(IEC104_Net_Listen("0.0.0.0", port, &listener, &bound, NULL) == IEC104_NET_OK, "Listen");
CHECK(listener != IEC104_NET_INVALID_SOCKET && bound == port, "Listen outputs");
return listener;
}
/* 不重新 Init:代次切换后的重建只调 Listen(Init 会重置句柄计数,掩盖 ABA)。 */
static IEC104_NetSocket_t listen_only(uint16_t port)
{
IEC104_NetSocket_t listener = IEC104_NET_INVALID_SOCKET;
uint16_t bound = 0;
CHECK(IEC104_Net_Listen("0.0.0.0", port, &listener, &bound, NULL) == IEC104_NET_OK,
"Listen without Init");
CHECK(listener != IEC104_NET_INVALID_SOCKET && bound == port, "Listen outputs");
return listener;
}
static IEC104_NetSocket_t setup_accept(IEC104_NetSocket_t listener, uint8_t octet)
{
IEC104_NetSocket_t client = IEC104_NET_INVALID_SOCKET;
IEC104_NetPeer_t peer;
memset(&peer, 0, sizeof(peer));
CHECK(net_fake_peer_arrive(octet, (uint16_t)(40000U + octet)) == 1, "peer arrive");
CHECK(IEC104_Net_Accept(listener, &client, &peer, NULL) == IEC104_NET_OK, "Accept");
CHECK(peer.port == (uint16_t)(40000U + octet), "peer port");
return client;
}
static void N1_close_keeps_listener(void)
{
IEC104_NetSocket_t l, c;
net_fake_stats_t st;
current_case = "N1";
net_fake_reset();
l = setup_listen(24001);
c = setup_accept(l, 11);
CHECK(c != l, "logical client handle differs from listener");
CHECK(IEC104_Net_Close(c, NULL) == IEC104_NET_OK, "Close session");
net_fake_stats(&st);
CHECK(st.listen_closed_attempts == 0, "listener never net_close'd");
CHECK(st.drop_conn_calls >= 1, "net_drop_conn used");
CHECK(net_fake_listen_fd() >= 0, "listener survives");
(void)setup_accept(l, 12);
net_fake_stats(&st);
CHECK(st.accept_calls >= 2, "second Accept works");
CHECK(st.listen_closed_attempts == 0, "still no listener close");
}
static void drain_input(IEC104_NetSocket_t client, size_t expected, int degraded)
{
uint8_t buf[128];
size_t total = 0;
int rounds = 0;
while (total < expected && rounds++ < 256) {
uint32_t available = 0xFFFFFFFFU;
int ne = 0;
IEC104_NetResult_t pr = IEC104_Net_Pending_Input(client, &available, &ne);
size_t budget;
IEC104_NetIoResult_t r;
if (pr == IEC104_NET_OK && available == 0 && degraded == 0) {
break;
}
if (degraded == 2 || pr == IEC104_NET_ERROR) {
available = (uint32_t)sizeof(buf);
}
budget = available > sizeof(buf) ? sizeof(buf) : available;
if (budget == 0U) {
budget = sizeof(buf);
}
r = IEC104_Net_Recv(client, buf, budget);
if (r.result == IEC104_NET_OK) {
total += r.transferred;
} else if (r.result == IEC104_NET_EOF) {
break;
}
}
CHECK(total == expected, "all bytes delivered");
}
static void N2_pending_input(void)
{
IEC104_NetSocket_t l, c;
static const uint8_t data[300] = {0};
current_case = "N2a";
net_fake_reset();
l = setup_listen(24002);
c = setup_accept(l, 21);
CHECK(net_fake_push_rx(data, (int)sizeof(data)) == (int)sizeof(data), "queue 300B");
drain_input(c, sizeof(data), 0);
current_case = "N2b";
net_fake_reset();
l = setup_listen(24003);
c = setup_accept(l, 22);
{
uint32_t n = 0xFFFFFFFFU;
static const uint8_t seven[7] = {1, 2, 3, 4, 5, 6, 7};
CHECK(net_fake_push_rx(seven, 7) == 7, "queue 7B exact probe");
CHECK(IEC104_Net_Pending_Input(c, &n, NULL) == IEC104_NET_OK && n == 7,
"Pending_Input exact 7");
{
uint8_t tmp[8];
IEC104_NetIoResult_t rr = IEC104_Net_Recv(c, tmp, sizeof(tmp));
CHECK(rr.result == IEC104_NET_OK && rr.transferred == 7, "drain 7B exact probe");
}
n = 0xFFFFFFFFU;
CHECK(IEC104_Net_Pending_Input(c, &n, NULL) == IEC104_NET_OK && n == 0,
"Pending_Input exact 0 (empty)");
}
CHECK(net_fake_push_rx(data, (int)sizeof(data)) == (int)sizeof(data), "queue 300B degraded");
net_fake_set_recv_len_degraded(1);
drain_input(c, sizeof(data), 1);
net_fake_reset();
l = setup_listen(24009);
c = setup_accept(l, 23);
CHECK(net_fake_push_rx(data, (int)sizeof(data)) == (int)sizeof(data), "queue 300B under-report");
net_fake_set_recv_len_degraded(2);
drain_input(c, sizeof(data), 2);
}
static void N3_send_short_write(void)
{
IEC104_NetSocket_t l, c;
uint8_t bufs[20][20];
uint8_t sent[64];
net_fake_stats_t st;
size_t i, off = 0;
int rounds = 0;
current_case = "N3";
net_fake_reset();
l = setup_listen(24004);
c = setup_accept(l, 31);
for (i = 0; i < sizeof(bufs) / sizeof(bufs[0]); ++i) {
size_t k;
for (k = 0; k < sizeof(bufs[0]); ++k) {
bufs[i][k] = (uint8_t)(0x41 + k);
}
}
net_fake_set_send_mode(FAKE_SEND_SHORT, 2, 3);
while (off < sizeof(bufs[0]) && rounds++ < 20) {
IEC104_NetIoResult_t r = IEC104_Net_Send(c, bufs[rounds - 1] + off,
sizeof(bufs[0]) - off);
if (r.result == IEC104_NET_OK) {
off += r.transferred;
}
memset(bufs[rounds - 1], 0xEE, sizeof(bufs[0]));
}
CHECK(off == sizeof(bufs[0]), "short-write progressed to completion");
net_fake_stats(&st);
CHECK(st.bytes_sent == (int)sizeof(bufs[0]), "kernel accepted all bytes");
CHECK(net_fake_copy_tx(sent, (int)sizeof(sent)) == (int)sizeof(bufs[0]),
"fake kernel holds all 20 bytes");
{
size_t k;
for (k = 0; k < sizeof(bufs[0]); ++k) {
CHECK((unsigned char)sent[k] == (unsigned char)(0x41 + k),
"in-flight bytes match pre-mutation payload");
}
}
}
static void N4_now_ms_wrap(void)
{
uint64_t a, b, c;
current_case = "N4";
net_fake_reset();
(void)IEC104_Net_Init(NULL);
net_fake_set_tick(0xFFFFFFF0U);
a = IEC104_Net_Now_Ms();
net_fake_set_tick(0xFFFFFFFFU);
b = IEC104_Net_Now_Ms();
net_fake_set_tick(0x00000000U);
c = IEC104_Net_Now_Ms();
CHECK(b > a, "monotonic before wrap");
CHECK(c > b, "monotonic across 0xFFFFFFFF -> 0");
CHECK((int)(c - b) == 1, "one tick = one ms across wrap");
}
static void N5_generation_invalidates(void)
{
IEC104_NetSocket_t l, c;
uint8_t b[4] = {1, 2, 3, 4};
current_case = "N5";
net_fake_reset();
l = setup_listen(24005);
c = setup_accept(l, 51);
net_fake_generation_inc();
{
IEC104_NetIoResult_t rr = IEC104_Net_Send(c, b, sizeof(b));
CHECK(rr.result == IEC104_NET_ERROR && rr.native_error == NET_ERR_BADF,
"stale client Send ERROR/BADF");
}
{
char rb[8];
IEC104_NetIoResult_t rr = IEC104_Net_Recv(c, rb, sizeof(rb));
CHECK(rr.result == IEC104_NET_ERROR && rr.native_error == NET_ERR_BADF,
"stale client Recv ERROR/BADF");
}
{
uint32_t n = 0;
CHECK(IEC104_Net_Pending_Input(c, &n, NULL) == IEC104_NET_ERROR,
"stale client Pending_Input ERROR");
CHECK(n == 0, "Pending failure leaves output unchanged");
}
{
IEC104_NetSocket_t client = IEC104_NET_INVALID_SOCKET;
IEC104_NetPeer_t peer;
memset(&peer, 0, sizeof(peer));
CHECK(IEC104_Net_Accept(l, &client, &peer, NULL) == IEC104_NET_ERROR,
"stale listener Accept ERROR");
CHECK(client == IEC104_NET_INVALID_SOCKET, "failed Accept output untouched");
}
{
net_fake_stats_t before, after;
net_fake_stats(&before);
CHECK(IEC104_Net_Close(c, NULL) == IEC104_NET_OK, "stale Close idempotent OK");
net_fake_stats(&after);
CHECK(after.listen_closed_attempts == before.listen_closed_attempts,
"stale Close touches no hardware");
CHECK(after.hardware_calls == before.hardware_calls,
"stale Close makes no net_* call");
}
/* 新 Listen 清掉过期槽,新建监听可用。 */
l = setup_listen(24006);
c = setup_accept(l, 52);
CHECK(IEC104_Net_Send(c, b, sizeof(b)).result == IEC104_NET_OK,
"new generation handle usable");
}
static void N6_fd_reuse_no_cross_talk(void)
{
IEC104_NetSocket_t l, c1, c2;
uint8_t b[4] = {9, 9, 9, 9};
net_fake_stats_t st;
current_case = "N6";
net_fake_reset();
l = setup_listen(24007);
c1 = setup_accept(l, 61);
CHECK(IEC104_Net_Close(c1, NULL) == IEC104_NET_OK, "close first session");
net_fake_stats(&st);
CHECK(st.listen_closed_attempts == 0, "listener intact after close");
CHECK(net_fake_listen_fd() >= 0, "listener fd alive");
CHECK(IEC104_Net_Send(c1, b, sizeof(b)).result == IEC104_NET_ERROR,
"stale handle cannot write after close");
CHECK(IEC104_Net_Close(c1, NULL) == IEC104_NET_OK, "stale close is idempotent");
net_fake_stats(&st);
CHECK(st.listen_closed_attempts == 0, "stale close never touches listener");
c2 = setup_accept(l, 62);
CHECK(c2 != c1, "new client handle differs from stale one");
CHECK(IEC104_Net_Send(c2, b, sizeof(b)).result == IEC104_NET_OK,
"new session usable after stale close");
}
static void N7_reconnect_net_layer(void)
{
IEC104_NetSocket_t l, c, c2;
uint8_t b[2] = {0x68, 0x04};
current_case = "N7";
net_fake_reset();
l = setup_listen(24008);
c = setup_accept(l, 71);
CHECK(IEC104_Net_Send(c, b, sizeof(b)).result == IEC104_NET_OK,
"first session sends");
net_fake_peer_reset();
CHECK(IEC104_Net_Recv(c, b, sizeof(b)).result == IEC104_NET_ERROR, "RST observed");
CHECK(IEC104_Net_Close(c, NULL) == IEC104_NET_OK, "close broken session");
CHECK(net_fake_listen_fd() >= 0, "listener survives RST close");
c2 = setup_accept(l, 72);
CHECK(c2 != c, "new client handle after reconnect");
CHECK(IEC104_Net_Send(c2, b, sizeof(b)).result == IEC104_NET_OK,
"new session sends after reconnect");
}
static void N8_close_preserves_listener(void)
{
IEC104_NetSocket_t l, c, c2;
net_fake_stats_t st;
current_case = "N8";
net_fake_reset();
l = setup_listen(24010);
c = setup_accept(l, 81);
CHECK(IEC104_Net_Close(c, NULL) == IEC104_NET_OK, "first Close");
net_fake_stats(&st);
CHECK(st.listen_closed_attempts == 0, "first Close never net_close'd listener");
CHECK(net_fake_listen_fd() >= 0, "listener alive after first Close");
c2 = setup_accept(l, 82); CHECK(c2 != IEC104_NET_INVALID_SOCKET, "second Accept on same listener succeeded");
net_fake_stats(&st);
CHECK(st.listen_closed_attempts == 0, "machine counter still zero");
CHECK(net_fake_listen_fd() >= 0, "same physical listener still alive");
}
static void N9_non_owner_rejected(void)
{
IEC104_NetSocket_t l = IEC104_NET_INVALID_SOCKET;
IEC104_NetSocket_t c = IEC104_NET_INVALID_SOCKET;
IEC104_NetSocket_t bad = (IEC104_NetSocket_t)1U;
uint16_t bound = 0;
IEC104_NetPeer_t peer;
uint8_t buf[4] = {1, 2, 3, 4};
uint32_t available = 0;
uint32_t ready = 0xFFFFFFFFU;
net_fake_stats_t before, after;
int ne = 0;
current_case = "N9";
net_fake_reset();
net_fake_set_owner(0U); /* 本测试进程 = 明确非 owner 上下文 */
CHECK(IEC104_Net_Init(&ne) == IEC104_NET_ERROR && ne == NET_ERR_INVAL,
"Init rejects non-owner");
CHECK(IEC104_Net_Listen("0.0.0.0", 24011, &l, &bound, &ne) == IEC104_NET_ERROR &&
ne == NET_ERR_INVAL && l == IEC104_NET_INVALID_SOCKET && bound == 0,
"Listen rejects non-owner with outputs unchanged");
memset(&peer, 0, sizeof(peer));
CHECK(IEC104_Net_Accept(bad, &c, &peer, &ne) == IEC104_NET_ERROR && ne == NET_ERR_INVAL,
"Accept rejects non-owner");
{
IEC104_NetIoResult_t rr = IEC104_Net_Recv(bad, buf, sizeof(buf));
CHECK(rr.result == IEC104_NET_ERROR && rr.native_error == NET_ERR_INVAL,
"Recv rejects non-owner");
}
CHECK(IEC104_Net_Pending_Input(bad, &available, &ne) == IEC104_NET_ERROR &&
ne == NET_ERR_INVAL && available == 0,
"Pending_Input rejects non-owner, output unchanged");
{
IEC104_NetIoResult_t rr = IEC104_Net_Send(bad, buf, sizeof(buf));
CHECK(rr.result == IEC104_NET_ERROR && rr.native_error == NET_ERR_INVAL,
"Send rejects non-owner");
}
CHECK(IEC104_Net_Wait(bad, bad, IEC104_NET_EVENT_READ, 0U, &ready, &ne) == IEC104_NET_ERROR &&
ne == NET_ERR_INVAL && ready == 0xFFFFFFFFU,
"Wait rejects non-owner, output unchanged");
net_fake_stats(&before);
CHECK(IEC104_Net_Close(bad, &ne) == IEC104_NET_ERROR && ne == NET_ERR_INVAL,
"Close rejects non-owner");
net_fake_stats(&after);
CHECK(after.hardware_calls == before.hardware_calls, "zero hardware access");
net_fake_set_owner(1U);
}
static void N10_generation_two_handles(void)
{
IEC104_NetSocket_t h1, h2, h3;
uint8_t b[4] = {1, 2, 3, 4};
net_fake_stats_t before, after;
current_case = "N10";
net_fake_reset();
h1 = setup_listen(24012);
h2 = setup_accept(h1, 91);
CHECK(h2 != h1, "client handle differs from listener handle");
net_fake_generation_inc();
{
IEC104_NetIoResult_t rr = IEC104_Net_Send(h2, b, sizeof(b));
CHECK(rr.result == IEC104_NET_ERROR && rr.native_error == NET_ERR_BADF,
"stale client handle rejected after generation change");
}
{
IEC104_NetSocket_t c = IEC104_NET_INVALID_SOCKET;
IEC104_NetPeer_t peer;
memset(&peer, 0, sizeof(peer));
CHECK(IEC104_Net_Accept(h1, &c, &peer, NULL) == IEC104_NET_ERROR,
"stale listener handle rejected after generation change");
}
net_fake_stats(&before);
CHECK(IEC104_Net_Close(h2, NULL) == IEC104_NET_OK, "stale client Close idempotent OK");
net_fake_stats(&after);
CHECK(after.hardware_calls == before.hardware_calls,
"stale client Close touches no hardware");
CHECK(after.listen_closed_attempts == 0,
"stale client Close never closes listener (absolute zero)");
/* 正向断言:代次推进后旧监听资源已随芯片复位失效;此时不得靠旧 fd
* 继续 armed。下一行重建后的 armed==1 才是 A7 要的“监听资源存活”。 */
CHECK(net_fake_listener_armed() == 0,
"stale generation cleared old listener before rebuild");
/* 新代次重建监听;旧槽已在 Listen 内清掉。故意不调 Init(Init 会重置
* 句柄计数),因此 h3 必须严格大于旧句柄,证明没有 ABA 复用。 */
h3 = listen_only(24013);
CHECK(h3 > h1 && h3 > h2, "new listener handle is fresh, not ABA-reused");
CHECK(net_fake_listener_armed() == 1,
"rebuilt listener is armed (net_listener_armed == 1)");
net_fake_stats(&after);
CHECK(after.listen_closed_attempts == 0,
"listener_closed_attempts is explicitly zero after rebuild");
CHECK(IEC104_Net_Send(setup_accept(h3, 92), b, sizeof(b)).result == IEC104_NET_OK,
"new generation client works");
}
/* 正向证明库手里的首个 client 句柄 H1 仍有效:Send 成功 + 会话 fd 未变
* (H1 若被 memset 悬空,Send 会走 find_client 失败返回 ERROR+NET_ERR_BADF)。 */
static void check_client_handle_live(IEC104_NetSocket_t client, int fd_before)
{
uint8_t b[1] = { 'x' };
CHECK(IEC104_Net_Send(client, b, sizeof(b)).result == IEC104_NET_OK,
"H1 handle still resolves to live CLIENT slot after refused re-Accept");
CHECK(net_fake_session_fd() == fd_before, "H1 session fd unchanged");
}
static void N11_accept_is_one_shot_until_client_closed(void)
{
IEC104_NetSocket_t h1, client, second;
IEC104_NetPeer_t peer;
net_fake_stats_t before, after;
int fd_before;
current_case = "N11";
net_fake_reset();
h1 = setup_listen(24014);
client = setup_accept(h1, 93);
fd_before = net_fake_session_fd();
/* 台架 2026-11-18 定案:单 fd 下 net_accept_locked 对 ESTABLISHED 幂等
* 成功,库的 4 次预算循环会再调 Accept 并把刚发的句柄当"多余客户端"
* Close(同 fd → 拆掉活连接)。新语义:同一会话只交付一次,第二次
* Accept 必须 WOULD_BLOCK,且不发任何芯片事务、不拆旧会话。 */
memset(&peer, 0, sizeof(peer));
net_fake_stats(&before);
second = IEC104_NET_INVALID_SOCKET;
CHECK(IEC104_Net_Accept(h1, &second, &peer, NULL) == IEC104_NET_WOULD_BLOCK,
"second Accept returns WOULD_BLOCK (one-shot per session)");
CHECK(second == IEC104_NET_INVALID_SOCKET, "second Accept leaves client output untouched");
net_fake_stats(&after);
CHECK(after.drop_conn_calls == before.drop_conn_calls,
"second Accept never drops the live same-fd session");
CHECK(after.hardware_calls == before.hardware_calls,
"gate is pure RAM: no chip transaction when a session exists");
CHECK(after.listen_closed_attempts == 0, "listener still intact");
CHECK(net_fake_listener_armed() == 1, "listener still armed");
/* 旧槽仍有效:正向三条 —— H1 能命中 CLIENT 槽并 Send 成功、会话 fd 不变、
* 与监听槽同 fd(库两句柄模型的 fd 契约)。H1 若被旧 memset 段清掉,
* Send 会 find_client 失败返回 ERROR+NET_ERR_BADF,这条立即红。 */
check_client_handle_live(client, fd_before);
CHECK(net_fake_session_fd() == net_fake_listen_fd(),
"H1 still shares listener fd (no new session fd allocated)");
/* Close 旧会话后闸自动释放:下一次 Accept 仍能接入,不会永久静默拒连。 */
CHECK(IEC104_Net_Close(client, NULL) == IEC104_NET_OK, "close old client OK");
second = setup_accept(h1, 94);
CHECK(second != IEC104_NET_INVALID_SOCKET && second != client,
"new client accepted after old client closed (no permanent lockout)");
}
static void N12_wait_reports_no_accept_while_session_active(void)
{
IEC104_NetSocket_t l, c;
uint32_t ready = 0xFFFFFFFFU;
current_case = "N12";
net_fake_reset();
l = setup_listen(24015);
/* 会话在役前:armed 监听应如实报 ACCEPT 就绪(现网新连接可接入)。 */
CHECK(IEC104_Net_Wait(l, IEC104_NET_INVALID_SOCKET, IEC104_NET_EVENT_ACCEPT,
0U, &ready, NULL) == IEC104_NET_OK, "Wait before session OK");
CHECK((ready & IEC104_NET_EVENT_ACCEPT) != 0U,
"ACCEPT ready reported when no client session exists");
/* 会话在役后:net_listener_armed 对 ESTABLISHED 恒返 1,旧实现每轮报
* 假 ACCEPT → 库每轮再调 Accept(重复 Accept 引擎);新闸必须如实报
* "无接入需求",这样即使 Accept 侧闸缺失也不再触发重复接入。 */
c = setup_accept(l, 95);
ready = 0xFFFFFFFFU;
CHECK(IEC104_Net_Wait(l, c, IEC104_NET_EVENT_ACCEPT,
0U, &ready, NULL) == IEC104_NET_OK, "Wait during session OK");
CHECK((ready & IEC104_NET_EVENT_ACCEPT) == 0U,
"ACCEPT NOT ready while client session active (single fd is data channel)");
/* Close 后释放:再次 Wait 应恢复 ACCEPT 就绪,证明不是永久静默拒接。 */
CHECK(IEC104_Net_Close(c, NULL) == IEC104_NET_OK, "close session OK");
ready = 0xFFFFFFFFU;
CHECK(IEC104_Net_Wait(l, IEC104_NET_INVALID_SOCKET, IEC104_NET_EVENT_ACCEPT,
0U, &ready, NULL) == IEC104_NET_OK, "Wait after close OK");
CHECK((ready & IEC104_NET_EVENT_ACCEPT) != 0U,
"ACCEPT ready again after session closed");
}
int main(void)
{
printf("=== IEC104 Net MCU real-backend contract tests (bad=%d) ===\n", NETMCU_BAD);
N1_close_keeps_listener();
N2_pending_input();
N3_send_short_write();
N4_now_ms_wrap();
N5_generation_invalidates();
N6_fd_reuse_no_cross_talk();
N7_reconnect_net_layer();
N8_close_preserves_listener();
N9_non_owner_rejected();
N10_generation_two_handles();
N11_accept_is_one_shot_until_client_closed();
N12_wait_reports_no_accept_while_session_active();
printf("=== IEC104 Net MCU real-backend contract tests: %d failures ===\n", failures);
return failures ? 1 : 0;
}