STM32F4-Base/test/host/net_socket/ns_s7_udp.c

/*
 * 模块名称：UDP 数据面分片（net_socket 主机侧单测，2026-11-03 UDP 队列化改造）
 * 模块功能：钉 UDP 从"调用方上下文直调 SPI"改为"netMsgQueue 交 netTask 串行执行"
 *           之后的全部契约，以及改造顺带修掉的**芯片模式缺陷**：
 *             - DesIP=0xFFFFFFFF（服务器模式）收包带 8 字节信息头；
 *             - DesIP=具体 IP（客户端模式）收包**没有**信息头。
 *           改造前 recvfrom 恒剥 8 字节，客户端模式（SNTP 这类请求-应答）等于吃掉
 *           载荷前 8 字节并回填一个假源地址——本分片用**逐字节内容**把两种模式钉死。
 *
 * 与既有分片的分工：
 *   - ns_s5/ns_s6 里 440/555/560 三组是"改造前形态"的历史钉子，已按新契约改写；
 *   - 本分片只测**队列化之后**新增或变化的决策：出参经 per-fd 槽回传、挂起 recv、
 *     截断排空、模式切换、以及"任何一条出口都必须通知调用方"。
 *
 * ⚠ 断言只钉真实契约（AGENTS 模块约定 + docs/芯片手册/CH395F.md §9.2.4 +
 *   docs/问题记录/CH395F_Trap_Records.md），不钉假件规则。
 *
 * 创建日期：2026-11-03
 */

/* 造一个"已 bind 的 UDP fd"（bind 走队列，故调用前的上下文决定走哪条路） */
static int udp_bind(int port_host)
{
    struct net_sockaddr_in in;
    int fd = net_socket(NET_AF_INET, NET_SOCK_DGRAM);

    (void)memset(&in, 0, sizeof(in));
    in.sin_family = NET_AF_INET;
    in.sin_port = net_htons((uint16_t)port_host);
    if (net_bind(fd, (const struct net_sockaddr *)&in, (int)sizeof(in)) != 0) {
        return -1;
    }
    return fd;
}

/* 组一个"服务器模式数据报"的字节流：8 字节信息头 + n 字节载荷，写进假芯片的
 * 可读流并返回总长。头与载荷是分两次读的，所以内容必须按芯片缓冲的真实字节序预置。 */
static int udp_build_server_datagram(uint8_t *buf, int cap, const char *payload, int n,
                                     uint16_t src_port_host, const char *src_ip)
{
    uint8_t ip[4];
    int i;

    if (n + 8 > cap) {
        return -1;
    }
    (void)memset(buf, 0, (size_t)(8 + n));
    parse_ip_string(src_ip, ip);
    buf[0] = (uint8_t)(n & 0xFF);         /* [0-1] 数据长度（本层不消费，仅占位） */
    buf[1] = (uint8_t)((n >> 8) & 0xFF);
    buf[2] = (uint8_t)(src_port_host & 0xFFU);   /* [2-3] 源端口：芯片小端 */
    buf[3] = (uint8_t)((src_port_host >> 8) & 0xFFU);
    buf[4] = ip[0];                       /* [4-7] 源 IP 线序：首段在低地址 */
    buf[5] = ip[1];
    buf[6] = ip[2];
    buf[7] = ip[3];
    for (i = 0; i < n; i++) {
        buf[8 + i] = (uint8_t)payload[i];
    }
    return 8 + n;
}

/* "此刻就有这一个数据报可读"：流 + 长度一起给（多数用例走这条） */
static void udp_script_server_datagram(const char *payload, int n,
                                       uint16_t src_port_host, const char *src_ip)
{
    uint8_t buf[128];
    int total = udp_build_server_datagram(buf, (int)sizeof(buf), payload, n,
                                          src_port_host, src_ip);

    if (total < 0) {
        return;
    }
    ch395f_fake_set_recv_stream(buf, (uint16_t)total);
    ch395f_fake_push_recv_len(0, (uint16_t)total);    /* 覆盖所有 fd：只有一个在用 */
}

/* "内容先备好、长度还没宣布"：测"先没有、后面才到"必须这样分——
 * 芯片长度才是"有没有包"的唯一依据，长度一宣布就是"现在就有"。 */
static void udp_stage_server_datagram(const char *payload, int n,
                                      uint16_t src_port_host, const char *src_ip)
{
    uint8_t buf[128];
    int total = udp_build_server_datagram(buf, (int)sizeof(buf), payload, n,
                                          src_port_host, src_ip);

    if (total < 0) {
        return;
    }
    ch395f_fake_set_recv_stream(buf, (uint16_t)total);
}

/* s_net_udp 是 net_udp.c 的生产 static：本分片直接读它的挂起标志，
 * 不为了测试在生产里开一个只读 API（既有分片同样直读 s_net_socks）。 */
static int net_udp_pending(int fd)
{
    return (s_net_udp[fd].pending != 0U) ? 1 : 0;
}

static int net_udp_armed(int fd)
{
    return (s_net_udp[fd].armed != 0U) ? 1 : 0;
}

/* 手工投一条 UDP 收包消息（不经公开入口）：公开入口在"挂起"这条出口上会睡在
 * 任务通知里，测试拿不到"已登记、回执未发"这个中间态；这里自己装消息自己入队，
 * 再自己以 netTask 身份泵一轮，断言登记与取消。与 net_recvfrom_impl 的入队段逐字同形。 */
static void udp_arm_and_enqueue(int fd, void *buf, int len, uint32_t to_ms, net_msg_t *msg)
{
    (void)memset(msg, 0, sizeof(*msg));
    msg->type = NET_MSG_UDP_RECVFROM;
    msg->sockfd = fd;
    msg->buf = buf;
    msg->len = len;
    msg->timeout_ms = to_ms;
    msg->caller = (TaskHandle_t)&g_ns_task_caller;
    (void)net_udp_outparam_arm(fd, NULL, NULL);
    (void)ns_rtos_q_put_raw(msg);
}

/* ================= UDP-1 bind：命令序列与模式复位 ================= */

static void tc_udp1_bind_sequence(void)
{
    struct net_sockaddr_in in;
    int fd;

    bring_up();
    fd = net_socket(NET_AF_INET, NET_SOCK_DGRAM);
    (void)memset(&in, 0, sizeof(in));
    in.sin_family = NET_AF_INET;
    in.sin_port = net_htons(123U);

    /* 队列化：调用方任务里 bind 不该碰芯片一下（TRAP-NET-14 的正面形态） */
    ch395f_fake_clear_log();
    CHECK(net_bind(fd, (const struct net_sockaddr *)&in, (int)sizeof(in)) == 0,
          "UDP-1a caller-context bind succeeds (enqueued, executed in netTask, result via notify)");
    CHECK(s_net_socks[fd].state == NET_SOCK_STATE_UDP_OPEN,
          "UDP-1b state UDP_OPEN (open succeeded, no listen state in UDP)");
    CHECK(s_net_socks[fd].udp_mode == NET_UDP_MODE_SERVER,
          "UDP-1c bind is always server mode (BSD bind names a local port, it never picks a peer)");
    CHECK(g_fx.des_ip[fd][0] == 0xFFU && g_fx.des_ip[fd][1] == 0xFFU &&
          g_fx.des_ip[fd][2] == 0xFFU && g_fx.des_ip[fd][3] == 0xFFU &&
          g_fx.des_port[fd] == 0U,
          "UDP-1d DesIP=0xFFFFFFFF + DesPort=0 (the hardware definition of server mode)");
    CHECK(g_chip.last_proto == CH395F_PROTO_TYPE_UDP && g_chip.last_port == 123U,
          "UDP-1e proto UDP then source port 123 (handbook §9.2.4 order)");
    CHECK(ch395f_fake_log_find('P') >= 0 &&
          ch395f_fake_log_find('P') < ch395f_fake_log_find('o'),
          "UDP-1f DesIP/ports come BEFORE OPEN_SOCKET (open resets them: the ordering is the bug fix)");
    CHECK(g_chip.open_calls == 1, "UDP-1g exactly one open");

    /* 端口 0 = 动态取号，取号游标在 netTask 内推进（原来在调用方上下文改静态量） */
    reset_all();
    bring_up();
    fd = net_socket(NET_AF_INET, NET_SOCK_DGRAM);
    (void)memset(&in, 0, sizeof(in));
    in.sin_family = NET_AF_INET;
    CHECK(net_bind(fd, (const struct net_sockaddr *)&in, (int)sizeof(in)) == 0,
          "UDP-1h bind with port 0 succeeds");
    CHECK(s_net_socks[fd].local_port == 49152U && g_chip.last_port == 49152U,
          "UDP-1i dynamic port allocated inside netTask and written to the chip (no cross-context write to s_dynamic_port)");
    reset_all();
}

/* ================= UDP-2 未 bind 的接口一律拒绝（新收紧） ================= */

static void tc_udp2_requires_bind(void)
{
    struct net_sockaddr_in in;
    struct net_sockaddr *sa = (struct net_sockaddr *)&in;
    char buf[16];
    int fd;

    bring_up();
    fd = net_socket(NET_AF_INET, NET_SOCK_DGRAM);
    (void)memset(&in, 0, sizeof(in));
    in.sin_family = NET_AF_INET;
    in.sin_port = net_htons(123U);
    in.sin_addr.s_addr = net_inet_addr("192.168.31.9");

    CHECK(net_sendto(fd, "hi", 2, 0, sa, (int)sizeof(in)) == -1 &&
          net_get_errno() == NET_ERR_NOTCONN,
          "UDP-2a sendto before bind -> NOTCONN (an unopened chip socket cannot send)");
    CHECK(net_recvfrom(fd, buf, (int)sizeof(buf), NET_MSG_DONTWAIT, NULL, NULL) == -1 &&
          net_get_errno() == NET_ERR_NOTCONN,
          "UDP-2b recvfrom before bind -> NOTCONN");
    CHECK(net_udp_set_peer(fd, &in) == -1 && net_get_errno() == NET_ERR_NOTCONN,
          "UDP-2c set_peer before bind -> NOTCONN (writing DesIP before open would be reset by open)");
    CHECK(g_chip.write_calls == 0 && g_chip.open_calls == 0 && g_fxchip.set_des_ip_calls == 0,
          "UDP-2d a refusal is a clean refusal: no write, no open, no DesIP");
    reset_all();
}

/* ================= UDP-3 服务器模式：剥头 + 源地址逐字节 ================= */

static void tc_udp3_server_strip(void)
{
    struct net_sockaddr_in in;
    struct net_sockaddr *sa = (struct net_sockaddr *)&in;
    char buf[64];
    int addrlen;
    int fd;
    int rc;

    bring_up();
    fd = udp_bind(123);
    CHECK(fd >= 0, "UDP-3a bind precondition");

    /* 载荷 20 字节，头里写着 src 192.168.31.9:51999 */
    udp_script_server_datagram("ABCDEFGHIJKLMNOPQRST", 20, 51999U, "192.168.31.9");
    s_net_socks[fd].readable = 1U;
    addrlen = (int)sizeof(in);
    (void)memset(&in, 0, sizeof(in));
    rc = net_recvfrom(fd, buf, (int)sizeof(buf), 0, sa, &addrlen);
    CHECK(rc == 20, "UDP-3b server mode returns the payload length only (20 of 28 chip bytes)");
    CHECK((int)g_fx.recv_pos == 28,
          "UDP-3c the whole datagram was read out (header + payload): the handbook requires draining in one go");
    CHECK(memcmp(buf, "ABCDEFGHIJKLMNOPQRST", 20) == 0,
          "UDP-3d delivered bytes are the payload, byte for byte (not the header, not shifted)");
    CHECK(addrlen == (int)sizeof(in) && in.sin_family == NET_AF_INET,
          "UDP-3e source address filled and addrlen reported");
    CHECK(in.sin_addr.s_addr == net_inet_addr("192.168.31.9"),
          "UDP-3f source IP matches the net_inet_addr family (line-order header -> network-order s_addr, no extra byteswap)");
    CHECK(net_ntohs(in.sin_port) == 51999U,
          "UDP-3g source port: chip little-endian in the header, network-order in the struct");
    CHECK(s_net_socks[fd].readable == 0U,
          "UDP-3h readable cleared after the read (a level-triggered event must not fire the same packet twice)");
    CHECK(s_net_socks[fd].recv_bytes == 20U,
          "UDP-3i statistics count delivered payload, not the chip header");
    reset_all();
}

/* ================= UDP-4 客户端模式：不剥头（改造修的缺陷本体） ================= */

static void tc_udp4_client_no_strip(void)
{
    struct net_sockaddr_in in;
    struct net_sockaddr *sa = (struct net_sockaddr *)&in;
    uint8_t stream[64];
    char buf[64];
    int addrlen;
    int fd;
    int rc;
    int i;

    bring_up();
    fd = udp_bind(123);
    (void)memset(&in, 0, sizeof(in));
    in.sin_family = NET_AF_INET;
    in.sin_port = net_htons(123U);
    in.sin_addr.s_addr = net_inet_addr("119.28.220.214");
    CHECK(net_udp_set_peer(fd, &in) == 0, "UDP-4a set_peer to an NTP-like server succeeds");
    CHECK(s_net_socks[fd].udp_mode == NET_UDP_MODE_CLIENT, "UDP-4b mode is now client");
    CHECK(g_fx.des_ip[fd][0] == 119U && g_fx.des_ip[fd][1] == 28U &&
          g_fx.des_ip[fd][2] == 220U && g_fx.des_ip[fd][3] == 214U &&
          g_fx.des_port[fd] == 123U,
          "UDP-4c DesIP carries the peer octets in line order (the chip's own byte convention)");
    CHECK(g_chip.open_calls == 1,
          "UDP-4d switching mode does NOT reopen the socket (a reopen would drop buffered replies)");

    /* 48 字节 SNTP 应答，前 8 字节故意长得像"信息头"——旧实现会把它们剥掉 */
    (void)memset(stream, 0, sizeof(stream));
    for (i = 0; i < 48; i++) {
        stream[i] = (uint8_t)(0x24 + i);      /* 0x24 = LI=0,VN=4,Mode=3 起手 */
    }
    ch395f_fake_set_recv_stream(stream, 48U);
    ch395f_fake_push_recv_len((uint8_t)fd, 48U);
    s_net_socks[fd].readable = 1U;
    addrlen = (int)sizeof(in);
    (void)memset(&in, 0, sizeof(in));
    rc = net_recvfrom(fd, buf, (int)sizeof(buf), 0, sa, &addrlen);
    CHECK(rc == 48,
          "UDP-4e client mode delivers ALL 48 bytes (the pre-refactor build returned 40 and silently ate the first 8)");
    CHECK((uint8_t)buf[0] == 0x24U && (uint8_t)buf[7] == 0x2BU,
          "UDP-4f the first delivered byte is the reply itself, not the byte after a stripped header");
    CHECK(in.sin_addr.s_addr == net_inet_addr("119.28.220.214") &&
          net_ntohs(in.sin_port) == 123U,
          "UDP-4g source address comes from this socket's peer bookkeeping (client mode has no header to read)");
    reset_all();
}

/* ================= UDP-5 带地址发送 = 切客户端模式，不带地址 = 不动 ================= */

static void tc_udp5_sendto_dest_switches_mode(void)
{
    struct net_sockaddr_in in;
    struct net_sockaddr *sa = (struct net_sockaddr *)&in;
    int fd;

    bring_up();
    fd = udp_bind(123);
    ch395f_fake_enable_write_capture();
    (void)memset(&in, 0, sizeof(in));
    in.sin_family = NET_AF_INET;
    in.sin_port = net_htons(8888);
    in.sin_addr.s_addr = net_inet_addr("192.168.31.9");

    CHECK(net_sendto(fd, "ping", 4, 0, sa, (int)sizeof(in)) == 4, "UDP-5a sendto with a destination returns the byte count");
    CHECK(s_net_socks[fd].udp_mode == NET_UDP_MODE_CLIENT,
          "UDP-5b an explicit destination silently switches the chip to client mode: the software now books it (that is the whole point of udp_mode)");
    CHECK(g_fx.des_ip[fd][3] == 9U && g_fx.des_port[fd] == 8888U,
          "UDP-5c the destination travels with this one send (address is per packet in UDP)");
    CHECK(g_fx.write_cap_n == 4U && g_fx.write_bytes == 4U &&
          memcmp(g_fx.write_cap, "ping", 4) == 0,
          "UDP-5d the chip received exactly the caller's bytes, not a copy of something else");
    CHECK(s_net_socks[fd].remote_port == 8888U &&
          s_net_socks[fd].remote_ip == net_inet_addr("192.168.31.9"),
          "UDP-5e peer bookkeeping written in the same family as net_connect (remote_ip is network order)");

    /* 不带地址：DesIP 保持上次的对端，模式也不动；载荷按写入顺序续在捕获流后面。
     * 上一块的 SENBUF_FREE 不在本场景要考的范围内（挂起续传见 TC-NETSOCK-506d），
     * 这里直接把"缓冲又空了"这一步做掉，等价于 net_poll 收到 SENBUF_FREE。 */
    s_net_socks[fd].send_ready = 1U;
    (void)memset(&in, 0, sizeof(in));
    CHECK(net_sendto(fd, "pong", 4, 0, NULL, 0) == 4, "UDP-5f sendto with NULL destination succeeds");
    CHECK(g_fx.write_bytes == 8U && memcmp(&g_fx.write_cap[4], "pong", 4) == 0,
          "UDP-5g the destination-less send still carries the caller's own bytes (the chunk pointer is advanced, not re-based)");
    CHECK(g_fx.des_ip[fd][3] == 9U && g_fx.des_port[fd] == 8888U,
          "UDP-5h NULL destination means reuse, not reset (unchanged DesIP/DesPort)");
    CHECK(s_net_socks[fd].udp_mode == NET_UDP_MODE_CLIENT, "UDP-5i mode unchanged by a destination-less send");
    reset_all();
}

/* ================= UDP-6 挂起 recv：数据到达即结束（netTask 零占用） ================= */

/* 泵：以 netTask 身份跑一轮分派，并按脚本伪造"某一轮才有数据"。
 * 真机上 netTask 是 1ms 主循环，HAL_GetTick 自己走；这里的假时钟必须由泵推进，
 * 否则挂起 recv 的 deadline 永远不到点（表现为等满 50 轮被假件判成漏通知）。
 *   s_udp_pump_arrive_round < 0  → 纯推进时钟，不注入数据（测超时用）
 *   s_udp_pump_len > 0           → 到那一轮置 readable 并给出该长度的芯片数据 */
static int s_udp_pump_arrive_round = -1;
static int s_udp_pump_fd;
static int s_udp_pump_len;
static uint32_t s_udp_pump_tick_inc = 1U;
static int s_udp_pump_calls;

static void udp_pump(void)
{
    if ((s_udp_pump_arrive_round >= 0) && (s_udp_pump_calls == s_udp_pump_arrive_round)) {
        s_net_socks[s_udp_pump_fd].readable = 1U;
        ch395f_fake_push_recv_len((uint8_t)s_udp_pump_fd, (uint16_t)s_udp_pump_len);
    }
    s_udp_pump_calls++;
    g_ns_tick += s_udp_pump_tick_inc;
    net_process_messages();
}

static void udp_pump_stop(void)
{
    g_ns_pump = net_process_messages;
    s_udp_pump_arrive_round = -1;
    s_udp_pump_len = 0;
    s_udp_pump_tick_inc = 1U;
}

static void tc_udp6_pending_recv_arrival(void)
{
    struct net_sockaddr_in in;
    struct net_sockaddr *sa = (struct net_sockaddr *)&in;
    char buf[32];
    int addrlen;
    int fd;
    int rc;

    bring_up();
    fd = udp_bind(123);
    s_udp_pump_fd = fd;
    /* 内容先备好但**不宣布长度**：第 0 轮芯片缓冲是空的，数据报到第 1 轮才出现
     * （8 字节头 + 12 字节载荷）——顺序反了就变成"一进来就有数据"，测不到挂起 */
    udp_stage_server_datagram("TIME12345678", 12, 51999U, "192.168.31.9");
    ch395f_fake_push_recv_len((uint8_t)fd, 0U);
    s_udp_pump_arrive_round = 1;
    s_udp_pump_len = 8 + 12;
    s_udp_pump_calls = 0;
    g_ns_pump = udp_pump;
    g_ns_int_pin_set = 0;                 /* 有 INT# 电平但不注入 SINT：readable 由泵自己造 */
    addrlen = (int)sizeof(in);
    (void)memset(&in, 0, sizeof(in));

    rc = net_recvfrom_to(fd, buf, (int)sizeof(buf), 5000U, sa, &addrlen);
    udp_pump_stop();

    CHECK(rc == 12, "UDP-6a a blocked recv ends with the datagram that arrives later (the caller slept on its own notification, not on a spin)");
    CHECK(memcmp(buf, "TIME12345678", 12) == 0, "UDP-6b the late datagram's payload is delivered to the caller buffer");
    CHECK(net_ntohs(in.sin_port) == 51999U, "UDP-6c the source address is filled by netTask into the caller's own memory (no return field on net_msg_t)");
    CHECK(s_udp_pump_calls >= 2,
          "UDP-6d the wait really slept and was woken by the completion notify (at least one pump round between)");
    reset_all();
}

/* ================= UDP-7 挂起 recv：到点返回 -2 且不占 errno ================= */

static void tc_udp7_pending_timeout(void)
{
    char buf[8];
    int fd;
    int rc;
    int puts_before;
    int reads_before;

    bring_up();
    fd = udp_bind(123);
    ch395f_fake_push_recv_len((uint8_t)fd, 0U);
    g_ns_tick = 1000U;

    /* 预算 10ms：不注入任何数据，泵每轮把假时钟推到 deadline 之后 */
    s_udp_pump_arrive_round = -1;
    s_udp_pump_tick_inc = 10U;
    s_udp_pump_calls = 0;
    g_ns_pump = udp_pump;
    rc = net_recvfrom_to(fd, buf, (int)sizeof(buf), 10U, NULL, NULL);
    udp_pump_stop();

    CHECK(rc == -2, "UDP-7a the budget expired -> -2 (a timeout is a result, not an error - same contract as net_recv_to)");
    CHECK(g_ns_error_count == 0,
          "UDP-7b a timeout logs nothing and does not steal the caller's errno slot");
    CHECK(s_net_socks[fd].state == NET_SOCK_STATE_UDP_OPEN, "UDP-7c the socket stays usable after a timeout");
    CHECK(net_udp_pending(fd) == 0 && net_udp_armed(fd) == 0,
          "UDP-7d the timeout hands both the pending flag and the out-param slot back (a leaked slot pins the fd as BUSY forever)");

    /* 超时后立刻再来一次，数据到了必须能收到（槽位没泄漏的正面证据） */
    udp_script_server_datagram("AFTER", 5, 7U, "10.0.0.1");
    s_net_socks[fd].readable = 1U;
    rc = net_recvfrom(fd, buf, (int)sizeof(buf), NET_MSG_DONTWAIT, NULL, NULL);
    CHECK(rc == 5, "UDP-7e the same fd receives normally right after a timeout");

    /* 预算 0 被这个入口拒绝：0 在本层一律是"无限等待"，而本接口存在的理由就是
     * 有界（与 net_recv_to 的分片长度检查同口径）——静默改成无限等会把 IWDG 咬死 */
    puts_before = g_ns_put_calls;
    reads_before = g_chip.read_calls;
    rc = net_recvfrom_to(fd, buf, (int)sizeof(buf), 0U, NULL, NULL);
    CHECK(rc == -1 && net_get_errno() == NET_ERR_INVAL,
          "UDP-7f recvfrom_to with timeout_ms = 0 is refused as INVAL (0 means forever, which is what this entry must never do)");
    CHECK(g_ns_put_calls == puts_before && g_chip.read_calls == reads_before,
          "UDP-7g the refused budget never reaches the queue or the chip");
    reset_all();
}

/* ================= UDP-8 挂起 recv 被取消：close / 重建 ================= */

static void tc_udp8_pending_cancel(void)
{
    char buf[16];
    net_msg_t msg;
    int fd;

    /* 关闭结算：无数据 -> CONNRESET 必通知 */
    bring_up();
    fd = udp_bind(123);
    ch395f_fake_push_recv_len((uint8_t)fd, 0U);
    udp_arm_and_enqueue(fd, buf, (int)sizeof(buf), 0U, &msg);
    g_ns_cur_task = (TaskHandle_t)&g_ns_task_net;
    net_process_messages();
    CHECK(net_udp_pending(fd) == 1, "UDP-8a the receive is registered (netTask occupancy is zero while waiting)");
    (void)net_close_locked(&s_net_socks[fd]);
    CHECK(net_udp_pending(fd) == 0, "UDP-8b close settles the pending slot (nothing may outlive the fd)");
    CHECK(g_ns_notify_last_to == (TaskHandle_t)&g_ns_task_caller &&
          g_ns_notify_last_val == (uint32_t)(int)NET_ERR_CONNRESET,
          "UDP-8c the waiter is woken with CONNRESET, not left sleeping forever");
    reset_all();

    /* 关闭结算：有数据 -> 先把这一包送达（与 net_pending_settle_close 同一契约） */
    bring_up_netctx();
    fd = udp_bind(123);
    udp_script_server_datagram("LASTPKT", 7, 9U, "10.0.0.2");
    ch395f_fake_push_recv_len((uint8_t)fd, 15U);
    g_ns_cur_task = (TaskHandle_t)&g_ns_task_caller;
    if (net_udp_outparam_arm(fd, NULL, NULL) != 0) {
        CHECK(0, "UDP-8d arm the slot for the settle test");
    }
    s_net_udp[fd].pending = 1U;
    s_net_udp[fd].buf = buf;
    s_net_udp[fd].len = (int)sizeof(buf);
    s_net_udp[fd].caller = (TaskHandle_t)&g_ns_task_caller;
    g_ns_cur_task = (TaskHandle_t)&g_ns_task_net;
    net_udp_settle_close(fd, &s_net_socks[fd]);
    CHECK(g_ns_notify_last_val == 7U,
          "UDP-8e closing with a datagram already in the chip buffer delivers it (7 bytes) instead of cancelling");
    CHECK(memcmp(buf, "LASTPKT", 7) == 0, "UDP-8f the delivered payload is intact on the close path");
    reset_all();

    /* 网络重建：cancel_all 逐个通知 */
    bring_up_netctx();
    fd = udp_bind(123);
    ch395f_fake_push_recv_len((uint8_t)fd, 0U);
    g_ns_cur_task = (TaskHandle_t)&g_ns_task_caller;
    (void)net_udp_outparam_arm(fd, NULL, NULL);
    s_net_udp[fd].pending = 1U;
    s_net_udp[fd].buf = buf;
    s_net_udp[fd].len = (int)sizeof(buf);
    s_net_udp[fd].caller = (TaskHandle_t)&g_ns_task_caller;
    g_ns_cur_task = (TaskHandle_t)&g_ns_task_net;
    net_udp_cancel_all(NET_ERR_CONNRESET);
    CHECK(net_udp_pending(fd) == 0 && g_ns_notify_last_to == (TaskHandle_t)&g_ns_task_caller,
          "UDP-8g cancel_all wakes every waiter (the rebuild path cannot leave a task hanging)");
    reset_all();
}

/* ================= UDP-9 出参互斥与泄漏（AGENTS 禁止的回传字段，本改造的替代面） ================= */

static void tc_udp9_outparam_slot(void)
{
    struct net_sockaddr_in in;
    struct net_sockaddr *sa = (struct net_sockaddr *)&in;
    char buf[16];
    int addrlen;
    int fd;
    int rc;
    int puts_before;
    int reads_before;

    bring_up();
    fd = udp_bind(123);
    ch395f_fake_push_recv_len((uint8_t)fd, 0U);
    g_ns_int_pin_set = 0;
    /* 基线：bind 自己投过一条消息，"这次拒绝有没有投递"只能跟调用前的计数比 */
    puts_before = g_ns_put_calls;
    reads_before = g_chip.read_calls;

    /* 槽位被别的调用方占着：第二个并发收包必须被拒（数据报语义下无法判归属） */
    (void)memset(&in, 0, sizeof(in));
    in.sin_family = NET_AF_INET;
    addrlen = (int)sizeof(in);
    if (net_udp_outparam_arm(fd, sa, &addrlen) != 0) {
        CHECK(0, "UDP-9a arming a free slot succeeds");
    }
    rc = net_recvfrom(fd, buf, (int)sizeof(buf), NET_MSG_DONTWAIT, sa, &addrlen);
    CHECK(rc == -1 && net_get_errno() == NET_ERR_BUSY,
          "UDP-9b a second receiver on the same fd gets BUSY (two datagrams cannot be attributed to two callers)");
    CHECK(g_ns_put_calls == puts_before && g_chip.read_calls == reads_before,
          "UDP-9c the refusal is clean: nothing enqueued, nothing read from the chip");
    net_udp_outparam_disarm(fd);

    /* 入队前失败（队列满）不许把槽位钉住 */
    ns_rtos_q_fill(8);
    rc = net_recvfrom(fd, buf, (int)sizeof(buf), NET_MSG_DONTWAIT, sa, &addrlen);
    CHECK(rc == -1 && net_get_errno() == NET_ERR_BUSY, "UDP-9d a full queue -> BUSY");
    CHECK(s_net_udp[fd].armed == 0U,
          "UDP-9e the slot is given back on the enqueue-failure path (a leaked slot would pin this fd as BUSY forever)");
    ns_rtos_q_flush();
    reset_all();
}

/* ================= UDP-10 截断排空（旧实现留半包，下一包从此错位） ================= */

static void tc_udp10_truncation_drains(void)
{
    char buf[8];
    int fd;
    int rc;

    bring_up_netctx();
    fd = udp_bind(123);
    udp_script_server_datagram("0123456789ABCDE", 17, 9U, "10.0.0.3");
    ch395f_fake_push_recv_len((uint8_t)fd, 25U);
    rc = net_recvfrom(fd, buf, 4, NET_MSG_DONTWAIT, NULL, NULL);
    CHECK(rc == 4, "UDP-10a a short buffer yields exactly its capacity (BSD truncation)");
    CHECK(memcmp(buf, "0123", 4) == 0, "UDP-10b the first four payload bytes, header excluded");
    CHECK((int)g_fx.recv_pos == 25,
          "UDP-10c the WHOLE datagram was drained (25 chip bytes consumed): a leftover tail would desync every later packet");
    CHECK(g_ns_error_count >= 1,
          "UDP-10d the truncated drop is logged (silent byte loss is the hardest thing to debug)");
    CHECK(s_net_socks[fd].readable == 0U, "UDP-10e readable cleared after the full read");
    reset_all();
}

/* ================= UDP-11 执行任务自等自通知被拒（同 net_pending 守卫） ================= */

static void tc_udp11_self_wait_refused(void)
{
    char buf[16];
    int fd;

    bring_up_netctx();
    fd = udp_bind(123);
    ch395f_fake_push_recv_len((uint8_t)fd, 0U);
    g_ns_int_pin_set = 0;
    CHECK(net_recvfrom(fd, buf, (int)sizeof(buf), 0, NULL, NULL) == -1 &&
          net_get_errno() == NET_ERR_BUSY,
          "UDP-11a a blocking UDP receive inside netTask is refused (the tick that would complete it runs in that same task: self-wait = deadlock)");
    CHECK(net_recvfrom(fd, buf, (int)sizeof(buf), NET_MSG_DONTWAIT, NULL, NULL) == -1 &&
          net_get_errno() == NET_ERR_WOULDBLOCK,
          "UDP-11b the same call with NET_MSG_DONTWAIT is the legal netTask form -> WOULDBLOCK, no wait");
    reset_all();
}

/* ================= UDP-12 net_init 重建：挂起全部结算 ================= */

static void tc_udp12_rebuild_cancels(void)
{
    char buf[16];
    int fd;

    bring_up();
    fd = udp_bind(123);
    ch395f_fake_push_recv_len((uint8_t)fd, 0U);
    g_ns_cur_task = (TaskHandle_t)&g_ns_task_caller;
    (void)net_udp_outparam_arm(fd, NULL, NULL);
    s_net_udp[fd].pending = 1U;
    s_net_udp[fd].buf = buf;
    s_net_udp[fd].len = (int)sizeof(buf);
    s_net_udp[fd].caller = (TaskHandle_t)&g_ns_task_caller;
    g_ns_cur_task = (TaskHandle_t)&g_ns_task_net;

    (void)net_init("192.168.31.101", "255.255.255.0", "192.168.31.1", NULL);
    CHECK(net_udp_pending(fd) == 0,
          "UDP-12a a stack rebuild cancels every pending UDP receive (the same rule the TCP pending table follows)");
    CHECK(g_ns_notify_last_val == (uint32_t)(int)NET_ERR_CONNRESET,
          "UDP-12b the waiter is woken with CONNRESET on rebuild");
    reset_all();
}

/* ================= UDP-13 公开流式接口不接受 DGRAM（剥头只有一条路） ================= */

static void tc_udp13_stream_api_rejects_dgram(void)
{
    char buf[16];
    int fd;

    bring_up_netctx();
    fd = udp_bind(123);
    udp_script_server_datagram("XYZW", 4, 9U, "10.0.0.4");
    ch395f_fake_push_recv_len((uint8_t)fd, 12U);
    CHECK(net_recv(fd, buf, (int)sizeof(buf), 0) == -1 && net_get_errno() == NET_ERR_INVAL,
          "UDP-13a net_recv on a DGRAM socket is refused (it reads raw and would hand the chip header over as data)");
    CHECK(net_recv_nb(fd, buf, (int)sizeof(buf)) == -1 && net_get_errno() == NET_ERR_INVAL,
          "UDP-13b net_recv_nb refused the same way (one UDP read path only: net_recvfrom)");
    CHECK(net_recv_to(fd, buf, (int)sizeof(buf), 100U) == -1 && net_get_errno() == NET_ERR_INVAL,
          "UDP-13c net_recv_to refused the same way");
    CHECK(g_chip.read_calls == 0, "UDP-13d refusal touched the chip zero times");
    reset_all();
}

/* ================= UDP-14 队列化改造的存在理由：调用方上下文零 SPI ================= */

static void tc_udp14_caller_context_zero_spi(void)
{
    struct net_sockaddr_in in;
    struct net_sockaddr *sa = (struct net_sockaddr *)&in;
    char buf[32];
    int addrlen;
    int fd;
    int reads_before;
    int writes_before;

    bring_up();
    fd = udp_bind(123);

    /* 调用方上下文：日志里出现任何一个芯片事务短名都算违反约定 */
    reads_before = g_chip.read_calls;
    writes_before = g_chip.write_calls;
    ch395f_fake_clear_log();
    udp_script_server_datagram("HELLO", 5, 53U, "192.168.31.200");
    ch395f_fake_push_recv_len((uint8_t)fd, 13U);
    s_net_socks[fd].readable = 1U;
    addrlen = (int)sizeof(in);
    (void)memset(&in, 0, sizeof(in));
    CHECK(net_recvfrom(fd, buf, (int)sizeof(buf), 0, sa, &addrlen) == 5,
          "UDP-14a caller-context recvfrom succeeds");
    CHECK(g_chip.read_calls == reads_before + 2,
          "UDP-14b exactly header + payload reads, all issued while netTask owned the pump (the caller blocked, it did not touch SPI)");
    CHECK(g_chip.write_calls == writes_before, "UDP-14c a receive writes nothing to the send buffer");
    CHECK(g_ns_block_waits >= 1,
          "UDP-14d the caller waited on its own task notification (this is what replaces the old spin-poll in the caller task)");
    reset_all();
}

/* ================= UDP-15 执行体与槽位的入参守卫（netTask 直调） ================= */

/* 这些守卫是"队列化之后仍然存在的第二条入口"：板级用例与 netTask 内部直调 exec。
 * 一旦入参检查松掉，轻则把越界 fd 当合法 fd 用，重则在 s_net_udp[] 上算出越界指针。
 * 断言顺带钉住"拒绝对芯片零操作"——守卫失败不许留下半个芯片事务。 */
static void tc_udp15_exec_arg_guards(void)
{
    struct net_sockaddr_in in;
    struct net_sockaddr *sa = (struct net_sockaddr *)&in;
    char buf[8];
    int udp_fd;
    int raw_fd;
    int stream_fd;
    int addrlen;
    int reads_before;
    int writes_before;
    int desip_before;

    bring_up_netctx();
    udp_fd = udp_bind(123);
    stream_fd = mk_sock(NET_SOCK_STREAM, NET_SOCK_STATE_ESTABLISHED);
    raw_fd = net_socket(NET_AF_INET, NET_SOCK_DGRAM);   /* 只 socket 不 bind */
    reads_before = g_chip.read_calls;
    writes_before = g_chip.write_calls;
    desip_before = g_fxchip.set_des_ip_calls;
    /* 越界 fd：四个执行体 + 槽位三件套 */
    CHECK(net_udp_bind_exec(-1, 123U) == -1 && net_get_errno() == NET_ERR_BADF,
          "UDP-15a bind_exec refuses a negative fd");
    CHECK(net_udp_bind_exec(NET_MAX_SOCKETS, 123U) == -1 && net_get_errno() == NET_ERR_BADF,
          "UDP-15b bind_exec refuses fd == NET_MAX_SOCKETS (the array has no such entry)");
    CHECK(net_udp_set_peer_exec(99, NULL) == -1 && net_get_errno() == NET_ERR_BADF,
          "UDP-15c set_peer_exec refuses an out-of-range fd");
    CHECK(net_udp_sendto_exec(-1, buf, 4, NULL, NULL) == -1 && net_get_errno() == NET_ERR_BADF,
          "UDP-15d sendto_exec refuses a negative fd");
    CHECK(net_udp_recvfrom_exec(NET_MAX_SOCKETS, buf, (int)sizeof(buf),
                                NET_MSG_DONTWAIT, 0U, NULL) == -1 &&
          net_get_errno() == NET_ERR_BADF,
          "UDP-15e recvfrom_exec refuses an out-of-range fd BEFORE it takes &s_net_udp[fd] (an out-of-range slot pointer is a wild write waiting to happen)");
    CHECK(net_udp_outparam_arm(-1, NULL, NULL) == -1 && net_get_errno() == NET_ERR_BADF,
          "UDP-15f the out-param slot refuses an out-of-range fd");

    /* 越界的 disarm/clear 只许静默返回，且不许碰合法槽位 */
    CHECK(net_udp_outparam_arm(udp_fd, NULL, NULL) == 0, "UDP-15g in-range arm succeeds");
    net_udp_outparam_disarm(-1);
    net_udp_clear(999);
    CHECK(net_udp_armed(udp_fd) == 1,
          "UDP-15h an out-of-range disarm/clear leaves the in-range slot exactly as it was");
    net_udp_outparam_disarm(udp_fd);
    CHECK(net_udp_armed(udp_fd) == 0, "UDP-15i the in-range disarm releases it");

    /* 类型不符：UDP 执行体不碰 TCP fd（bind/set_peer/recvfrom 看 type，sendto 看状态） */
    CHECK(net_udp_bind_exec(stream_fd, 123U) == -1 && net_get_errno() == NET_ERR_INVAL,
          "UDP-15j bind_exec on a STREAM fd is refused (a chip reopen would silently convert its protocol)");
    CHECK(net_udp_set_peer_exec(stream_fd, NULL) == -1 && net_get_errno() == NET_ERR_INVAL,
          "UDP-15k set_peer_exec on a STREAM fd is refused");
    CHECK(net_udp_recvfrom_exec(stream_fd, buf, (int)sizeof(buf),
                                NET_MSG_DONTWAIT, 0U, NULL) == -1 &&
          net_get_errno() == NET_ERR_INVAL,
          "UDP-15l recvfrom_exec on a STREAM fd is refused (stream reads belong to net_recv)");
    CHECK(net_udp_sendto_exec(stream_fd, buf, 4, NULL, NULL) == -1 &&
          net_get_errno() == NET_ERR_NOTCONN,
          "UDP-15m sendto_exec on a STREAM fd fails on the state gate (it shares net_send_locked, so the UDP-open check is the guard - not a type check)");

    /* 未 bind 的 UDP fd：芯片侧 Socket 还没开，三条执行体一律 NOTCONN */
    CHECK(net_udp_sendto_exec(raw_fd, buf, 4, NULL, NULL) == -1 &&
          net_get_errno() == NET_ERR_NOTCONN,
          "UDP-15n sendto_exec on an unbound UDP fd is refused (open would reset DesIP/DesPort written before it)");
    CHECK(net_udp_recvfrom_exec(raw_fd, buf, (int)sizeof(buf), NET_MSG_DONTWAIT, 0U, NULL) == -1 &&
          net_get_errno() == NET_ERR_NOTCONN,
          "UDP-15n2 recvfrom_exec on an unbound UDP fd is refused");
    CHECK(net_udp_set_peer_exec(raw_fd, NULL) == -1 && net_get_errno() == NET_ERR_NOTCONN,
          "UDP-15n3 set_peer_exec on an unbound UDP fd is refused");
    CHECK(net_udp_sendto_exec(raw_fd, buf, 0, NULL, NULL) == -1 && net_get_errno() == NET_ERR_INVAL,
          "UDP-15p a zero-length payload is refused before any state check");
    CHECK(net_udp_sendto_exec(raw_fd, NULL, 4, NULL, NULL) == -1 && net_get_errno() == NET_ERR_INVAL,
          "UDP-15q a NULL payload is refused");
    CHECK(net_udp_recvfrom_exec(raw_fd, NULL, (int)sizeof(buf), NET_MSG_DONTWAIT, 0U, NULL) == -1 &&
          net_get_errno() == NET_ERR_INVAL,
          "UDP-15r recvfrom_exec refuses a NULL buffer");
    CHECK(net_udp_recvfrom_exec(raw_fd, buf, 0, NET_MSG_DONTWAIT, 0U, NULL) == -1 &&
          net_get_errno() == NET_ERR_INVAL,
          "UDP-15s recvfrom_exec refuses a zero-capacity buffer");

    /* 公开入口：给了地址就必须给够长度（静默忽略 = 悄悄发到上一个对端） */
    (void)memset(&in, 0, sizeof(in));
    in.sin_family = NET_AF_INET;
    in.sin_port = net_htons(8888);
    in.sin_addr.s_addr = net_inet_addr("192.168.31.9");
    CHECK(net_sendto(udp_fd, buf, 4, 0, sa, 4) == -1 && net_get_errno() == NET_ERR_INVAL,
          "UDP-15t net_sendto with a destination but a short addrlen is refused");
    addrlen = 4;
    CHECK(net_recvfrom(udp_fd, buf, (int)sizeof(buf), NET_MSG_DONTWAIT, sa, &addrlen) == -1 &&
          net_get_errno() == NET_ERR_INVAL,
          "UDP-15u net_recvfrom with a src_addr but *addrlen too small is refused (it would half-fill the caller's struct)");
    CHECK(net_recvfrom(udp_fd, buf, (int)sizeof(buf), NET_MSG_DONTWAIT, sa, NULL) == -1 &&
          net_get_errno() == NET_ERR_INVAL,
          "UDP-15v net_recvfrom with src_addr but NULL addrlen is refused");
    CHECK(g_chip.read_calls == reads_before && g_chip.write_calls == writes_before &&
          g_fxchip.set_des_ip_calls == desip_before,
          "UDP-15w every one of these refusals left the chip untouched (a rejected call must not start a transaction)");

    /* 最后才是正例：端口 0 = 请本层分配动态端口（取号游标只有一个，就在 netTask 里） */
    CHECK(net_udp_bind_exec(raw_fd, 0U) == 0, "UDP-15x bind on a fresh UDP fd succeeds (port 0 = dynamic)");
    CHECK(s_net_socks[raw_fd].local_port >= 49152U && s_net_socks[raw_fd].state == NET_SOCK_STATE_UDP_OPEN,
          "UDP-15y the dynamic port came from the netTask-side cursor and the socket is open (the cursor used to be poked from whichever task called bind)");
    reset_all();
}

/* ================= UDP-16 包装层的失败出口：队列未绑定 / 队列满 ================= */

/* 队列化接口最怕的一种泄漏：出参槽登记成功、消息没投出去。槽位留在原地，
 * 这条 fd 之后每一次收包都被自己的旧登记判成 BUSY——而且永远不会自己好。 */
static void tc_udp16_wrapper_failure_exits(void)
{
    struct net_sockaddr_in in;
    struct net_sockaddr *sa = (struct net_sockaddr *)&in;
    char buf[16];
    int addrlen;
    /* 队列句柄存档（清掉之后要还原，还原走的是同一条 adopt 路径） */
    osMessageQueueId_t q_saved;
    int fd;
    int rc;

    bring_up();
    fd = udp_bind(123);
    q_saved = s_net_msg_queue;
    (void)memset(&in, 0, sizeof(in));
    in.sin_family = NET_AF_INET;
    in.sin_port = net_htons(456);
    in.sin_addr.s_addr = 0U;
    addrlen = (int)sizeof(in);

    /* 「执行任务已建档、队列还没绑上」这个窗口：net_init 早期，或 CubeMX 里
     * 根本没建 netMsgQueue 的构建。手工把队列指针清掉才能走到这条出口——
     * 未 net_init 时每个任务都被当成执行任务，走的是直调分支，到不了这里。
     * ⚠ 这条出口按模块惯例是**裸 NET_ERR、不记 errno**（它表达的是"这套构建没配好
     * 队列"，不是某次调用的可分类失败），所以这里只钉 -1，不钉 net_get_errno()。 */
    s_net_msg_queue = NULL;
    CHECK(net_bind(fd, sa, (int)sizeof(in)) == -1,
          "UDP-16a bind with no queue bound fails (never pretends success without an open)");
    CHECK(net_sendto(fd, "ping", 4, 0, NULL, 0) == -1,
          "UDP-16b sendto with no queue bound fails");
    CHECK(net_udp_set_peer(fd, NULL) == -1,
          "UDP-16c set_peer with no queue bound fails");
    rc = net_recvfrom(fd, buf, (int)sizeof(buf), 0, sa, &addrlen);
    CHECK(rc == -1,
          "UDP-16d recvfrom with no queue bound fails");
    CHECK(net_udp_armed(fd) == 0,
          "UDP-16e the failed send-back hands the out-param slot straight back");
    rc = net_recvfrom(fd, buf, (int)sizeof(buf), NET_MSG_DONTWAIT, sa, &addrlen);
    CHECK(rc == -1,
          "UDP-16f the NEXT call on the same fd fails the same way, not as BUSY - proof the slot did not leak");

    /* 队列满：投不进去 → BUSY，且槽位同样当场归还 */
    s_net_msg_queue = q_saved;
    ns_rtos_q_fill((int)NS_Q_CAP);
    CHECK(net_sendto(fd, "ping", 4, 0, NULL, 0) == -1 && net_get_errno() == NET_ERR_BUSY,
          "UDP-16g sendto on a full queue returns BUSY (osWaitForever on a queue nobody is draining would freeze the caller task)");
    CHECK(net_recvfrom(fd, buf, (int)sizeof(buf), 0, sa, &addrlen) == -1 &&
          net_get_errno() == NET_ERR_BUSY,
          "UDP-16h recvfrom on a full queue returns BUSY");
    CHECK(net_udp_armed(fd) == 0,
          "UDP-16i the full-queue exit hands the slot back too (this is the exit that used to poison the fd forever)");
    CHECK(net_udp_set_peer(fd, NULL) == -1 && net_get_errno() == NET_ERR_BUSY,
          "UDP-16j set_peer on a full queue returns BUSY");
    ns_rtos_q_flush();
    CHECK(net_recvfrom(fd, buf, (int)sizeof(buf), NET_MSG_DONTWAIT, NULL, NULL) == -1 &&
          net_get_errno() == NET_ERR_WOULDBLOCK,
          "UDP-16k once the queue drains, the same fd works normally again (the refusals above were stateless)");
    reset_all();
}

/* ================= UDP-17 公开 set_peer/get_mode 与"回服务器模式" ================= */

static void tc_udp17_set_peer_and_mode(void)
{
    struct net_sockaddr_in in;
    struct net_sockaddr *sa = (struct net_sockaddr *)&in;
    uint8_t stream[64];
    char buf[64];
    int addrlen;
    int fd;
    int raw_fd;
    int stream_fd;
    int rc;
    int i;

    bring_up();
    fd = udp_bind(123);
    raw_fd = net_socket(NET_AF_INET, NET_SOCK_DGRAM);
    stream_fd = mk_sock(NET_SOCK_STREAM, NET_SOCK_STATE_ESTABLISHED);

    CHECK(net_udp_get_mode(fd) == NET_UDP_MODE_SERVER,
          "UDP-17a a freshly bound UDP socket is in chip SERVER mode (that is what bind programs: DesIP=0xFFFFFFFF)");
    CHECK(net_udp_get_mode(-1) == -1 && net_get_errno() == NET_ERR_BADF,
          "UDP-17b get_mode refuses an out-of-range fd");
    CHECK(net_udp_get_mode(stream_fd) == -1 && net_get_errno() == NET_ERR_INVAL,
          "UDP-17c get_mode on a STREAM fd is INVAL (there is no such thing as its chip mode)");
    CHECK(net_udp_set_peer(raw_fd, NULL) == -1 && net_get_errno() == NET_ERR_NOTCONN,
          "UDP-17d set_peer before bind is refused (open would reset what we just wrote)");

    /* 切客户端模式（经队列，调用方上下文） */
    (void)memset(&in, 0, sizeof(in));
    in.sin_family = NET_AF_INET;
    in.sin_port = net_htons(123);
    in.sin_addr.s_addr = net_inet_addr("119.28.220.214");
    CHECK(net_udp_set_peer(fd, &in) == 0, "UDP-17e set_peer succeeds through the queue");
    CHECK(net_udp_get_mode(fd) == NET_UDP_MODE_CLIENT, "UDP-17f the socket is now CLIENT mode");
    CHECK(g_fx.des_ip[fd][0] == 119U && g_fx.des_ip[fd][3] == 214U &&
          g_fx.des_port[fd] == 123U,
          "UDP-17g the chip's destination registers carry the peer (line order, as the chip wants it)");
    CHECK(s_net_socks[fd].remote_ip == net_inet_addr("119.28.220.214") &&
          s_net_socks[fd].remote_port == 123U,
          "UDP-17h peer bookkeeping is written on the switch, not only on send (client-mode receive has no header to read)");
    CHECK(g_chip.open_calls == 1,
          "UDP-17i switching to client mode does NOT reopen the socket (a reopen would drop the reply already buffered - the whole reason SNTP can use this)");

    /* 回服务器模式：不重开，只把 DesIP/DesPort 复原并清对端账 */
    CHECK(net_udp_set_peer(fd, NULL) == 0, "UDP-17j set_peer(NULL) returns to server mode");
    CHECK(net_udp_get_mode(fd) == NET_UDP_MODE_SERVER, "UDP-17k mode is SERVER again");
    CHECK(g_fx.des_ip[fd][0] == 0xFFU && g_fx.des_ip[fd][1] == 0xFFU &&
          g_fx.des_ip[fd][2] == 0xFFU && g_fx.des_ip[fd][3] == 0xFFU &&
          g_fx.des_port[fd] == 0U,
          "UDP-17l the chip registers are back to the bind-time server values");
    CHECK(s_net_socks[fd].remote_ip == 0U && s_net_socks[fd].remote_port == 0U &&
          s_net_socks[fd].remote_ip_arr[0] == 0U,
          "UDP-17m the peer bookkeeping is cleared with the mode (a stale peer would be used as the source address by a later client-mode read)");
    CHECK(g_chip.open_calls == 1, "UDP-17n returning to server mode does not reopen either");

    /* 端到端：回到服务器模式后，收包又必须剥掉 8 字节信息头 */
    for (i = 0; i < 64; i++) {
        stream[i] = (uint8_t)(0xC0 + i);      /* 前 8 字节故意像信息头 */
    }
    ch395f_fake_set_recv_stream(stream, 20U);
    ch395f_fake_push_recv_len((uint8_t)fd, 20U);
    s_net_socks[fd].readable = 1U;
    addrlen = (int)sizeof(in);
    (void)memset(&in, 0, sizeof(in));
    rc = net_recvfrom(fd, buf, (int)sizeof(buf), 0, sa, &addrlen);
    CHECK(rc == 12,
          "UDP-17o after the mode was restored the header is stripped again (20 chip bytes in, 12 payload bytes out)");
    CHECK((uint8_t)buf[0] == (uint8_t)0xC8U && (uint8_t)buf[11] == (uint8_t)0xC0U + 19U,
          "UDP-17p delivery starts at the 9th chip byte: the header really is gone, not copied then skipped in the buffer");
    reset_all();
}

/* ================= UDP-18 挂起 sendto：分派处不许发第二次回执 ================= */

/* UDP 发送与 TCP 共用 net_send_locked：发送缓冲没空出来时登记挂起 send，由
 * net_send_pending_tick 续传。这条出口的正确性只有一句话：**回执只能有一份**，
 * 而且必须是续传完成那一份。登记时就回执，调用方会拿到 0x70000000 当字节数。 */
static void tc_udp18_pending_send_completes(void)
{
    static char payload[1400];
    int fd;
    int rc;
    int writes_before;

    bring_up();
    fd = udp_bind(123);
    writes_before = g_chip.write_calls;

    /* 没有 SENBUF_FREE：发送缓冲始终没空，一块都写不进去 */
    g_ns_int_pin_set = 0;
    s_net_socks[fd].send_ready = 0U;
    /* 假对端：续传由它下一轮的 tick 结算（真实实现在 net_pending 自己的单测里测） */
    ns_peers_arm_send_pending_done(fd, 1400);

    rc = net_sendto(fd, payload, (int)sizeof(payload), 0, NULL, 0);
    CHECK(rc == 1400,
          "UDP-18a the caller gets the byte count of the COMPLETED send (if the dispatch notified on registration, this would be 0x70000000 or an error)");
    CHECK(g_peers.send_reg_calls == 1 && g_peers.last_snd_len == 1400 &&
          g_peers.last_snd_sent == 0,
          "UDP-18b nothing was sent when the pending send was registered (0 of 1400) - the spin budget expired without a free send buffer");
    CHECK(g_chip.write_calls == writes_before,
          "UDP-18c a stalled UDP send wrote nothing to the chip (writing into a full send buffer is silently dropped - TRAP-NET-04)");
    CHECK(g_peers.state_down_calls >= 1,
          "UDP-18d the shared state predicate was consulted (UDP and TCP share one chunking implementation, so TRAP-NET-16 cannot come back as a second path)");
    reset_all();
}

/* ================= UDP-19 tick 的兜底：会话已死、陈旧电平、零长度 ================= */

static void tc_udp19_tick_fallbacks(void)
{
    char buf[16];
    int fd;
    int rc;
    int reads_before;
    int notifies_before;

    bring_up_netctx();
    fd = udp_bind(123);

    /* 挂起收包登记中，控制块被拆（close/复位/被别的任务抢走） */
    CHECK(net_udp_outparam_arm(fd, NULL, NULL) == 0, "UDP-19a slot armed for the fabricated wait");
    s_net_udp[fd].pending = 1U;
    s_net_udp[fd].buf = buf;
    s_net_udp[fd].len = (int)sizeof(buf);
    s_net_udp[fd].caller = (TaskHandle_t)&g_ns_task_caller;
    s_net_socks[fd].state = NET_SOCK_STATE_CLOSED;
    notifies_before = g_ns_notify_calls;

    net_udp_tick(s_net_socks);
    CHECK(net_udp_pending(fd) == 0,
          "UDP-19a2 a pending UDP receive whose socket died is settled in that same tick (nobody else will ever cancel it: reconcile ignores UDP)");
    CHECK(g_ns_notify_calls == notifies_before + 1 &&
          g_ns_notify_last_to == (TaskHandle_t)&g_ns_task_caller &&
          g_ns_notify_last_val == (uint32_t)(int)NET_ERR_CONNRESET,
          "UDP-19b the settlement notifies the waiter with the error code (a lost notification = that task sleeps on a port that no longer exists)");
    net_udp_tick(s_net_socks);
    CHECK(g_ns_notify_calls == notifies_before + 1,
          "UDP-19c the second tick settles nothing again (no double notification)");

    /* 陈旧 readable：标志说有、芯片说没有 → 清标志，请求继续等 */
    CHECK(net_udp_outparam_arm(fd, NULL, NULL) == 0, "UDP-19d re-armed for the stale-level case");
    s_net_udp[fd].pending = 1U;
    s_net_udp[fd].buf = buf;
    s_net_udp[fd].len = (int)sizeof(buf);
    s_net_udp[fd].caller = (TaskHandle_t)&g_ns_task_caller;
    s_net_socks[fd].state = NET_SOCK_STATE_UDP_OPEN;
    s_net_socks[fd].readable = 1U;
    ch395f_fake_push_recv_len((uint8_t)fd, 0U);
    reads_before = g_chip.read_calls;

    net_udp_tick(s_net_socks);
    CHECK(s_net_socks[fd].readable == 0U,
          "UDP-19e a stale readable flag is cleared (leaving it set = one wasted SPI query every millisecond, forever)");
    CHECK(net_udp_pending(fd) == 1, "UDP-19f a stale flag is not data - the request keeps waiting");
    CHECK(g_chip.read_calls == reads_before, "UDP-19g the empty chip was not read past the length query");
    net_udp_clear(fd);

    /* 零长度不许进剥头逻辑：剥几字节、拷几字节、排空几字节必须同源 */
    rc = net_udp_datagram_read(fd, &s_net_socks[fd], buf, (int)sizeof(buf), NULL, NULL, 0);
    CHECK(rc == 0, "UDP-19h datagram_read with avail == 0 delivers nothing (it must not invent a header out of a zero-length report)");
    rc = net_udp_datagram_read(fd, &s_net_socks[fd], buf, (int)sizeof(buf), NULL, NULL, -1);
    CHECK(rc == 0, "UDP-19i a negative length report is treated the same way");

    /* 越界的 settle_close 静默返回（幂等兜底，不崩、不误结算别的 fd） */
    CHECK(net_udp_outparam_arm(fd, NULL, NULL) == 0, "UDP-19j armed for the range-guard check");
    s_net_udp[fd].pending = 1U;
    s_net_udp[fd].caller = (TaskHandle_t)&g_ns_task_caller;
    notifies_before = g_ns_notify_calls;
    net_udp_settle_close(-1, &s_net_socks[fd]);
    net_udp_settle_close(NET_MAX_SOCKETS, &s_net_socks[fd]);
    CHECK(net_udp_pending(fd) == 1 && g_ns_notify_calls == notifies_before,
          "UDP-19k out-of-range settle_close settles nothing (it must not walk into a neighbouring fd's waiter)");
    reset_all();
}

/* ================= UDP-20 重绑必须给等待者一个了断 ================= */

static void tc_udp20_rebind_settles_waiter(void)
{
    struct net_sockaddr_in in;
    const struct net_sockaddr *sa = (const struct net_sockaddr *)&in;
    char buf[16];
    int fd;
    int notifies_before;

    bring_up_netctx();
    fd = udp_bind(123);

    /* 有人在等包（手工登记，理由同 UDP-12：公开入口一进挂起就睡在通知里） */
    CHECK(net_udp_outparam_arm(fd, NULL, NULL) == 0, "UDP-20a slot armed");
    s_net_udp[fd].pending = 1U;
    s_net_udp[fd].buf = buf;
    s_net_udp[fd].len = (int)sizeof(buf);
    s_net_udp[fd].caller = (TaskHandle_t)&g_ns_task_caller;
    notifies_before = g_ns_notify_calls;

    /* 另一个任务重新 bind 同一 fd：芯片侧重开，缓冲里可能到的包一起作废 */
    (void)memset(&in, 0, sizeof(in));
    in.sin_family = NET_AF_INET;
    in.sin_port = net_htons(456);
    CHECK(net_bind(fd, sa, (int)sizeof(in)) == 0, "UDP-20b the rebind itself succeeds");
    CHECK(g_ns_notify_calls == notifies_before + 1 &&
          g_ns_notify_last_val == (uint32_t)(int)NET_ERR_CONNRESET,
          "UDP-20c the rebind hands the waiter an explicit CONNRESET before reopening (clearing the slot without notifying = that task sleeps forever on a socket that was reopened under it)");
    CHECK(net_udp_pending(fd) == 0 && net_udp_armed(fd) == 0,
          "UDP-20d no slot survives the rebind (neither pending nor armed)");
    CHECK(s_net_socks[fd].local_port == 456U &&
          s_net_socks[fd].udp_mode == NET_UDP_MODE_SERVER &&
          s_net_socks[fd].readable == 0U,
          "UDP-20e the reopened socket is a clean server-mode socket: new port, SERVER mode, no inherited level");
    CHECK(g_chip.open_calls == 2, "UDP-20f a rebind is the HEAVY way back to server mode (it reopens; net_udp_set_peer(fd, NULL) is the light one)");
    reset_all();
}

/* ===== UDP-21 两条"错误不是超时"的出口：bind 满队列 + recvfrom_to 真失败 ===== */

static void tc_udp21_bind_and_recvfrom_to_exits(void)
{
    struct net_sockaddr_in in;
    const struct net_sockaddr *sa = (const struct net_sockaddr *)&in;
    char buf[8];
    int fd;
    int raw_fd;
    int chip_fd;

    bring_up();                          /* 调用方上下文：公开入口一律走队列 */
    fd = net_socket(NET_AF_INET, NET_SOCK_DGRAM);
    (void)memset(&in, 0, sizeof(in));
    in.sin_family = NET_AF_INET;
    in.sin_port = net_htons(1234);

    /* 队列被别的请求占满：bind 只能"排队等空位"，等不到就 BUSY，
     * 绝不能把 fd 留在半个打开状态（芯片侧一条命令都没发）。 */
    ns_rtos_q_fill((int)NS_Q_CAP);
    CHECK(net_bind(fd, sa, (int)sizeof(in)) == NET_ERR &&
          net_get_errno() == NET_ERR_BUSY,
          "UDP-21a bind on a saturated queue is BUSY, and the code is the caller's own -11 (not a bare -1 the caller cannot diagnose)");
    CHECK(s_net_socks[fd].state != NET_SOCK_STATE_UDP_OPEN && g_chip.open_calls == 0,
          "UDP-21b a refused bind opens nothing on the chip: the fd is still just created, not half-bound");
    ns_rtos_q_flush();

    /* 同一 fd 在队列腾空后必须能正常 bind：BUSY 是"这次没排上"，不是给 fd 投毒 */
    CHECK(net_bind(fd, sa, (int)sizeof(in)) == 0 &&
          s_net_socks[fd].state == NET_SOCK_STATE_UDP_OPEN,
          "UDP-21c the same fd binds fine once the queue drains (a BUSY refusal poisons nothing)");

    /* net_recvfrom_to 的"真错误"出口：结果 <0 且不是超时 → 原样带精确码回调用方。
     * 挑一个未 bind 的 DGRAM fd：芯片侧 Socket 还没开，执行体必返 NOTCONN。 */
    raw_fd = net_socket(NET_AF_INET, NET_SOCK_DGRAM);
    CHECK(net_recvfrom_to(raw_fd, buf, (int)sizeof(buf), 50U, NULL, NULL) == NET_ERR &&
          net_get_errno() == NET_ERR_NOTCONN,
          "UDP-21d net_recvfrom_to maps an execution failure to the precise code (NOTCONN here), and does not disguise it as a timeout");
    CHECK(net_udp_armed(raw_fd) == 0,
          "UDP-21e2 the refused attempt hands the out-param slot back (an armed slot left behind by a refusal turns this fd permanently BUSY, and the error only surfaces on the *next* caller)");
    CHECK(net_recvfrom_to(raw_fd, buf, (int)sizeof(buf), 50U, NULL, NULL) == NET_ERR &&
          net_get_errno() == NET_ERR_NOTCONN,
          "UDP-21e the same refusal repeats with the same code (BUSY here would mean the fd was poisoned by its own last failure)");

    /* 正向：预算内已有数据 → 返回字节数，不走 -2 */
    udp_script_server_datagram("time", 4, 123U, "10.20.30.40");
    CHECK(net_recvfrom(fd, buf, (int)sizeof(buf), NET_MSG_DONTWAIT, NULL, NULL) == 4,
          "UDP-21f sanity: the bound fd still delivers a queued datagram byte-for-byte");

    /* 执行体在**执行阶段**失败（不是入队失败）时，精确码要能回到等待方：
     * 真芯片 open 会回 ERR_BUSY，这条通道是整个"通知值即结果"设计的落点。
     * 用一个新 fd，别拿已经 bind 成功的那个——那会看不出"失败没把 fd 变成已 bind"。 */
    chip_fd = net_socket(NET_AF_INET, NET_SOCK_DGRAM);
    g_fake.open_rc[chip_fd] = CH395F_ERR_BUSY;
    (void)memset(&in, 0, sizeof(in));
    in.sin_family = NET_AF_INET;
    in.sin_port = net_htons(4567);
    CHECK(net_bind(chip_fd, sa, (int)sizeof(in)) == NET_ERR &&
          net_get_errno() == NET_ERR_BUSY,
          "UDP-21g a bind the chip refuses (open → ERR_BUSY) comes back through the notify channel as -1 + the precise BUSY, not a bare -1 and not a timeout");
    CHECK(s_net_socks[chip_fd].state != NET_SOCK_STATE_UDP_OPEN,
          "UDP-21h a failed bind does not leave the fd looking bound");
    g_fake.open_rc[chip_fd] = CH395F_ERR_SUCCESS;
    CHECK(net_bind(chip_fd, sa, (int)sizeof(in)) == 0 &&
          s_net_socks[chip_fd].state == NET_SOCK_STATE_UDP_OPEN &&
          s_net_socks[chip_fd].local_port == 4567U,
          "UDP-21i the same fd binds normally once the chip stops refusing");

    /* 队列里有"别人的失败"排在我这条之前：两条在同一轮被排空，
     * 覆盖式通知让我拿到的是**自己那条**的回执（后写覆盖先写）。
     * 既有 TC-NETSOCK-545 在 TCP 侧钉过同一形态，这里补 UDP bind 这一条。 */
    {
        net_msg_t stale;
        int ghost = 6;

        (void)memset(&stale, 0, sizeof(stale));
        stale.type = NET_MSG_UDP_BIND;
        stale.sockfd = ghost;                       /* 没 net_socket() 过的 fd：执行体必拒 */
        stale.len = 1234U;                          /* bind 的本地端口走 len（主机序） */
        stale.addr = in;
        stale.addrlen = (int)sizeof(in);
        stale.caller = (TaskHandle_t)&g_ns_task_caller;
        CHECK(ns_rtos_q_put_raw(&stale) == 0, "UDP-21j the ghost bind request is queued");

        (void)memset(&in, 0, sizeof(in));
        in.sin_family = NET_AF_INET;
        in.sin_port = net_htons(4567);
        CHECK(net_bind(chip_fd, sa, (int)sizeof(in)) == 0,
              "UDP-21k a stranger request settling first does not turn my own successful bind into an error (the completion that overwrites the notify value is mine)");
        ns_rtos_q_flush();
    }
    reset_all();
}

/* ===== UDP-22 netTask 直调路径：set_peer 的三条出口（板级用例走这条） ===== */

static void tc_udp22_set_peer_direct_ctx(void)
{
    struct net_sockaddr_in peer;
    int fd;
    int stream_fd;
    int puts_before;
    int set_ip_before;

    bring_up_netctx();                   /* 留在 netTask 上下文：owner → 直调，不经队列 */
    fd = udp_bind(777);
    puts_before = g_ns_put_calls;

    (void)memset(&peer, 0, sizeof(peer));
    peer.sin_family = NET_AF_INET;
    peer.sin_port = net_htons(123);
    peer.sin_addr.s_addr = net_inet_addr("119.28.220.214");

    CHECK(net_udp_set_peer(fd, &peer) == 0,
          "UDP-22a set_peer inside netTask runs directly (the board-test path) and succeeds");
    CHECK(g_ns_put_calls == puts_before,
          "UDP-22b the direct path does not enqueue a message (a self-addressed queue message would never be drained)");
    CHECK(net_udp_get_mode(fd) == NET_UDP_MODE_CLIENT &&
          g_fx.des_ip[fd][0] == 119U && g_fx.des_ip[fd][3] == 214U &&
          g_fx.des_port[fd] == 123U && g_chip.open_calls == 1,
          "UDP-22c direct set_peer writes DesIP/DesPort and flips to CLIENT without reopening the socket");

    CHECK(net_udp_set_peer(fd, NULL) == 0 &&
          net_udp_get_mode(fd) == NET_UDP_MODE_SERVER &&
          g_fx.des_ip[fd][0] == 0xFFU && g_fx.des_port[fd] == 0U,
          "UDP-22d NULL peer is the light way back to SERVER: registers restored, still no reopen");

    /* 越界 / 未使用 / 面向流：三种拒绝都必须零芯片事务 */
    set_ip_before = g_fxchip.set_des_ip_calls;
    CHECK(net_udp_set_peer(-1, &peer) == NET_ERR && net_get_errno() == NET_ERR_BADF,
          "UDP-22e negative fd is BADF on the direct path too");
    CHECK(net_udp_set_peer(NET_MAX_SOCKETS, &peer) == NET_ERR &&
          net_get_errno() == NET_ERR_BADF,
          "UDP-22f fd >= NET_MAX_SOCKETS is BADF (the range guard is what keeps s_net_udp[] in bounds)");
    CHECK(net_udp_set_peer(5, &peer) == NET_ERR && net_get_errno() == NET_ERR_BADF,
          "UDP-22g an in-range but unused fd is BADF before anything is touched");
    stream_fd = mk_sock(NET_SOCK_STREAM, NET_SOCK_STATE_ESTABLISHED);
    CHECK(net_udp_set_peer(stream_fd, &peer) == NET_ERR &&
          net_get_errno() == NET_ERR_INVAL,
          "UDP-22h set_peer on a STREAM fd is refused as INVAL (the type check runs before the state check: a TCP socket has no UDP mode to switch at all)");
    {
        int unbound = net_socket(NET_AF_INET, NET_SOCK_DGRAM);

        CHECK(net_udp_set_peer(unbound, &peer) == NET_ERR &&
              net_get_errno() == NET_ERR_NOTCONN,
              "UDP-22h2 an unbound DGRAM fd is refused as NOTCONN on the direct path too (DesIP written before open gets reset by open)");
    }
    CHECK(g_fxchip.set_des_ip_calls == set_ip_before,
          "UDP-22i every refusal above wrote zero chip registers (a refusal that already moved DesIP would leave the socket pointing at a peer nobody asked for)");
    reset_all();
}

/* ===== UDP-23 netTask 直调收包正例 + 槽位被占的 BUSY 出口 ===== */

static void tc_udp23_recvfrom_direct_ctx(void)
{
    struct net_sockaddr_in from;
    struct net_sockaddr *sa = (struct net_sockaddr *)&from;
    int alen = (int)sizeof(from);
    char buf[16];
    int fd;

    bring_up_netctx();
    fd = udp_bind(888);

    /* 数据已在芯片缓冲里：直调路径当场读出并就地经槽位写回源地址 */
    udp_script_server_datagram("ABCDEFGH", 8, 5353U, "10.1.2.3");
    CHECK(net_recvfrom(fd, buf, (int)sizeof(buf), 0, sa, &alen) == 8,
          "UDP-23a netTask-context recvfrom reads the datagram on the spot (board tests call it this way)");
    CHECK(memcmp(buf, "ABCDEFGH", 8) == 0,
          "UDP-23b the 8-byte info header is stripped and the payload starts at byte 0");
    CHECK(alen == (int)sizeof(from) && from.sin_addr.s_addr == net_inet_addr("10.1.2.3") &&
          from.sin_port == net_htons(5353),
          "UDP-23c the source address is written through the caller's pointer, on the direct path as well");
    CHECK(net_udp_armed(fd) == 0,
          "UDP-23d the slot is handed back by the execution body even on a synchronous hit");

    /* 假件的脚本长度耗尽后会**重复最后一个值**（表达"一直有数据"的持续态），
     * 这里显式宣布"没包了"，否则下面两条会把上一个包再读一遍。 */
    ch395f_fake_push_recv_len(0, 0U);

    /* 槽位被别人占着：本 fd 上必须 BUSY，且不去碰芯片、也不许动别人的槽 */
    CHECK(net_udp_outparam_arm(fd, NULL, NULL) == 0, "UDP-23e slot armed by somebody else");
    CHECK(net_recvfrom(fd, buf, (int)sizeof(buf), NET_MSG_DONTWAIT, sa, &alen) == NET_ERR &&
          net_get_errno() == NET_ERR_BUSY,
          "UDP-23f recvfrom while the out-param slot is taken is BUSY rather than writing through a pointer that belongs to another call (公开入口对外仍是 -1 + 精确码)");
    CHECK(net_udp_armed(fd) != 0,
          "UDP-23g the refusal does not steal the slot it did not own");
    (void)net_udp_outparam_disarm(fd);

    /* 直调 + 阻塞 + 无数据 = 自等，被守卫拒成 BUSY（tick 就在自己脚下跑，等谁都不会醒） */
    CHECK(net_recvfrom(fd, buf, (int)sizeof(buf), 0, NULL, NULL) == NET_ERR &&
          net_get_errno() == NET_ERR_BUSY,
          "UDP-23h a blocking recvfrom executed inside netTask refuses to register a pending slot nobody can settle (self-wait guard)");
    CHECK(net_udp_armed(fd) == 0 && net_udp_pending(fd) == 0,
          "UDP-23i that refusal leaves neither an armed nor a pending slot behind");
    reset_all();
}

/* ===================== 本分片入口 ===================== */

static void ns_run_s7(void)
{
    tc_udp1_bind_sequence();
    tc_udp2_requires_bind();
    tc_udp3_server_strip();
    tc_udp4_client_no_strip();
    tc_udp5_sendto_dest_switches_mode();
    tc_udp6_pending_recv_arrival();
    tc_udp7_pending_timeout();
    tc_udp8_pending_cancel();
    tc_udp9_outparam_slot();
    tc_udp10_truncation_drains();
    tc_udp11_self_wait_refused();
    tc_udp12_rebuild_cancels();
    tc_udp13_stream_api_rejects_dgram();
    tc_udp14_caller_context_zero_spi();
    tc_udp15_exec_arg_guards();
    tc_udp16_wrapper_failure_exits();
    tc_udp17_set_peer_and_mode();
    tc_udp18_pending_send_completes();
    tc_udp19_tick_fallbacks();
    tc_udp20_rebind_settles_waiter();
    tc_udp21_bind_and_recvfrom_to_exits();
    tc_udp22_set_peer_direct_ctx();
    tc_udp23_recvfrom_direct_ctx();
}