/*
 * 模块名称：NET 套接字核心（net_socket）主机侧单元测试
 * 模块功能：在 PC 上离线验证 Drivers/BSP/NET/net_socket.c 的**跨上下文决策面**。
 *           被测对象：真实源文件 #include 原样纳入（同 TU 内可直接驱动它的 static）。
 *
 * 分片（同一 TU 内按片组织；一个目录=一个模块名，所以只有一个 runner）：
*   分片 1 纯函数与 fd 表：inet_addr/inet_ntoa（E13 段序定案）、hton 与 ntoh 四件套、
 *      alloc_socket/net_get_sock/net_sock_raw 的边界、net_socket() 的"新 fd 不得继承"、
 *      net_bind 的动态端口与回绕、getsockname/getpeername、setblocking/set_event_cb/
 *      sock_state、net_poll 未初始化短路。
 *   分片 2 每任务错误码槽（E-03）+ 队列句柄绑定（adopt 幂等）：内核未跑→[0] 槽退化、
 *      不同任务不同槽位互不覆写、槽位用尽回退 [0]、临界区成对且不嵌套泄漏。
 *   分片 3 跨上下文消息面：八个 msg.type 全分派 + 结果经**任务通知值**回传 +
 *      "登记挂起即不发即时回执"（do_notify=0）+ 失败时把 netTask 自己槽位的精确
 *      错误码搭通知值带回来 + 调用方在自己的槽位里恢复 errno。
*   分片 4 状态机与闸门：监听门控 net_listener_armed 三支放行/其余挡下、net_can_read、
 *      net_poll 的"全局位命中才读本 Socket SINT、永不读全局"（B3/F-NET-7）、
 *      事件计数、每轮全量刷新驱动缓存 + sock_reset 步进（I1/E-02）。
*   分片 5 读写错误分支：send 分块上限/短写/挂起登记/末块不登记（NET_PENDING 拒收边界）、
 *      recv 快路径与 EOF vs WOULDBLOCK、connect 命令被拒的回滚、accept 的
 *      closed-with-readable 排空接受、close 的先结算再关芯片。
 *
 * ⚠ 断言只钉**真实契约**（AGENTS 模块约定 + docs/网络/网络自愈架构设计.md §4.10 +
 *   源码注释里的定案编号），不钉假件规则：凡"因为假件这么做所以断言这么做"的一律不写。
 *
 * 入口：int main(void)，返回 0=PASS / 1=FAIL。跑法见同目录 run_unit_test.py。
 *
 * 创建日期：2026-10-24
 */

#include <stdio.h>
#include <string.h>

#include "net_socket.h"
#include "net_types.h"
#include "net_pending.h"
#include "net_listener.h"
#include "net_events.h"
#include "ch395f.h"

/* dbg_log 桩的计数定义（桩头只 extern） */
int g_ns_info_count;
int g_ns_error_count;
int g_ns_debug_count;

/* —— 假件实现与生产源进同一个 TU（本仓主机单测既有做法）—— */
#include "ch395f_fake.c"
#include "ns_rtos.c"
#include "ns_peers.c"

/* —— 被测生产源 —— */
#include "net_socket.c"

/* ===================== 断言框架 ===================== */

static int s_total;
static int s_passed;
static int s_failed;

#define CHECK(cond, name) do {     s_total++;     if (cond) { s_passed++; printf("  PASS %s\n", name); }     else { s_failed++; printf("  FAIL %s (line %d)\n", name, __LINE__); } } while (0)

/* ===================== 槽位表只读小工具（断言用，不参与被测逻辑） ===================== */

static int ns_slot_owner_count(void)
{
    int i;
    int n = 0;

    for (i = 0; i < (int)NET_ERRNO_TASK_SLOTS; i++) {
        if (s_net_errno_slots[i].owner != NULL) {
            n++;
        }
    }
    return n;
}

static int ns_slot_index_of(TaskHandle_t h)
{
    int i;

    for (i = 0; i < (int)NET_ERRNO_TASK_SLOTS; i++) {
        if (s_net_errno_slots[i].owner == (void *)h) {
            return i;
        }
    }
    return -1;
}

/* ===================== 场景复位 ===================== */
/* 生产模块的 static 在场景之间会残留，每个场景开头必须显式清干净（漏一次红一片） */
static void reset_all(void)
{
    (void)memset(s_net_socks, 0, sizeof(s_net_socks));
    (void)memset(s_net_errno_slots, 0, sizeof(s_net_errno_slots));
    (void)memset(s_local_ip, 0, sizeof(s_local_ip));
    s_dynamic_port = 49152;
    s_net_generation = 0U;
    s_net_initialized = 0U;
    s_net_msg_queue = NULL;
    g_ns_info_count = 0;
    g_ns_error_count = 0;
    g_ns_debug_count = 0;
    ch395f_fake_reset();
    ns_rtos_reset();
    ns_peers_reset();
}

/* 把网络层拉到"已初始化 + 队列已绑定"的常态（绝大多数场景的前置） */
static void bring_up(void)
{
    static int s_fake_queue;        /* 句柄只是不透明标识，假内核不解引用 */

    reset_all();
    (void)net_msg_queue_adopt((osMessageQueueId_t)&s_fake_queue);
    /* 装泵：调用方阻塞等待时以 netTask 身份跑一轮消息分派（= 跨上下文那条链） */
    g_ns_pump = net_process_messages;
    (void)net_init("192.168.1.100", "255.255.255.0", "192.168.1.1", NULL);
    g_peers.pending_capture_calls = 0;   /* bring_up 内部的登记动作不该算进场景 */
    g_ns_error_count = 0;
    g_ns_info_count = 0;
}

/* 直接造一个在用的控制块（多数场景不需要走完整的 socket()/bind()） */
static int mk_sock(int type, net_sock_state_t state)
{
    int fd = net_socket(NET_AF_INET, type);

    if (fd < 0) {
        return fd;
    }
    s_net_socks[fd].state = state;
    return fd;
}
/* ===================== 分片：纯函数 / 错误码槽 / 消息面 / 状态机 / 读写分支 ===================== */
/* 一个目录 = 一个模块名（check_test_coverage 的发现规则），所以只有一个 runner 与一个
 * TU；分片以文件维度拆开，是为了让 1251 行口径的最大块能逐片推进、逐片可查。 */
#include "ns_s3_msg.c"
#include "ns_s4_state.c"
#include "ns_s5_io.c"
#include "ns_s6_edges.c"

/* = 分片 1 纯函数面与 fd 表 ===================== */

/* TC-NETSOCK-100 点分十进制 ↔ 32 位：钉**当前行为**并显式标注疑点（见报告）
 * 现状：net_inet_addr 把首段放在**最高字节**（0xC0A80164），而 net_getsockname 组装
 * s_addr 时把首段放在**最低字节**，net_inet_ntoa 只与后者互为逆——同一文件里
 * 存在两套字节序约定。这里逐条钉住，不替生产"圆场"。 */
static void tc_100_inet_helpers(void)
{
    char buf[16];

    reset_all();

    CHECK(net_inet_addr(NULL) == 0U, "TC-NETSOCK-100a inet_addr(NULL) 返 0（无效）");
    CHECK(net_inet_addr("192.168.1.100") == 0xC0A80164U,
          "TC-NETSOCK-100b inet_addr 首段落在最高字节（当前实现）");
    CHECK(net_inet_ntoa(0xC0A80164U, buf) == buf && strcmp(buf, "100.1.168.192") == 0,
          "TC-NETSOCK-100c ntoa(同一 32 位值) 与 inet_addr 不互逆（疑点已报，钉当前行为）");
    CHECK(net_inet_ntoa(0x6401A8C0U, buf) == buf && strcmp(buf, "192.168.1.100") == 0,
          "TC-NETSOCK-100d ntoa 与 getsockname 的 s_addr 约定互逆（E13 定案的段序：高段在前）");
    CHECK(net_inet_ntoa(0U, NULL) == NULL, "TC-NETSOCK-100e ntoa(NULL 缓冲) 返 NULL 不崩");
    /* 单段/缺分隔的容错：逐段解析，非数字段当 0（钉实现，不钉"应该是多少"） */
    CHECK(net_inet_addr("10.0.0.1") == 0x0A000001U, "TC-NETSOCK-100f inet_addr 10.0.0.1");
}

static void tc_101_byteorder(void)
{
    reset_all();

    CHECK(net_htons(0x1234U) == 0x3412U, "TC-NETSOCK-101a htons 换端");
    CHECK(net_ntohs(net_htons(80U)) == 80U, "TC-NETSOCK-101b htons/ntohs 互逆");
    CHECK(net_htonl(0x01020304U) == 0x04030201U, "TC-NETSOCK-101c htonl 换端");
    CHECK(net_ntohl(net_htonl(0xDEADBEEFU)) == 0xDEADBEEFU, "TC-NETSOCK-101d htonl/ntohl 互逆");
}

static void tc_102_parse_ip(void)
{
    uint8_t a[4];

    reset_all();

    (void)memset(a, 0xEE, sizeof(a));
    parse_ip_string(NULL, a);
    CHECK(a[0] == 0xEEU, "TC-NETSOCK-102a parse_ip_string(NULL) 直接返回，不写目标缓冲");
    parse_ip_string("192.168.1.100", a);
    CHECK(a[0] == 192U && a[1] == 168U && a[2] == 1U && a[3] == 100U,
          "TC-NETSOCK-102b parse_ip_string 段 0 落在 [0]（芯片 set_ip_addr 要的顺位）");
    parse_ip_string("10.20.30.40", NULL);   /* 只验不崩 */
    CHECK(1, "TC-NETSOCK-102c parse_ip_string 目标为 NULL 不崩");
}

static void tc_103_alloc_and_getsock(void)
{
    int i;
    int fd;
    net_sock_t *p;

    reset_all();

    CHECK(net_get_sock(-1) == NULL && net_get_sock(NET_MAX_SOCKETS) == NULL,
          "TC-NETSOCK-103a net_get_sock 越界返 NULL（含负数）");
    CHECK(net_get_sock(0) == NULL, "TC-NETSOCK-103b 未分配的槽位返 NULL");
    CHECK(net_sock_raw(3) == &s_net_socks[3],
          "TC-NETSOCK-103c net_sock_raw 不判 in_use（对账必须看到 CLOSED 槽位）");
    CHECK(net_sock_state(0) == -1, "TC-NETSOCK-103d 未占用 sock_state 返 -1 且不设 errno");

    /* 逐个占满：alloc_socket 线性扫描首个空闲槽 */
    for (i = 0; i < NET_MAX_SOCKETS; i++) {
        fd = net_socket(NET_AF_INET, NET_SOCK_STREAM);
        if (fd != i) {
            break;
        }
    }
    CHECK(i == NET_MAX_SOCKETS, "TC-NETSOCK-103e alloc_socket 按序分配 0..7");
    p = net_get_sock(0);
    CHECK(p != NULL && p->in_use == 1U, "TC-NETSOCK-103f 分配的槽位 in_use=1");

    reset_all();
}

static void tc_104_socket_no_inherit(void)
{
    int fd;
    net_sock_t *p;

    reset_all();

    fd = net_socket(NET_AF_INET, NET_SOCK_STREAM);
    CHECK(fd == 0, "TC-NETSOCK-104a net_socket 返回首个空闲 fd");
    p = &s_net_socks[fd];
    CHECK(p->ch395_sock == (uint8_t)fd, "TC-NETSOCK-104b 芯片 Socket 号与描述符一一对应");
    CHECK(p->state == NET_SOCK_STATE_CREATED && p->type == NET_SOCK_STREAM,
          "TC-NETSOCK-104c 初态 CREATED + 类型记下");
    CHECK(p->send_ready == 1U && p->readable == 0U,
          "TC-NETSOCK-104d 初态：发送缓冲视为空闲、无可读");
    /* 三条"新 fd 不得继承"的定案，逐条钉（都是真机上静默出错的形态） */
    CHECK(p->blocking == 1U, "TC-NETSOCK-104e blocking 默认必须显式置 1（BSD 语义）");
    CHECK(p->released_abnormal == 0U, "TC-NETSOCK-104f 不得继承上一条的释放原因（TRAP-NET-18）");
    CHECK(p->session_dead == 0U, "TC-NETSOCK-104g 不得继承上一条的会话结束电平（N-32 P1）");
    CHECK(g_peers.listener_clear_calls == 1 && g_peers.pending_clear_calls == 1 &&
          g_peers.send_clear_calls == 1,
          "TC-NETSOCK-104h 新 fd 必须清监听重试 + 两张挂起表（各一次）");

    /* 脏槽位复用：把上一条会话的残留写进去，再看新建是否清干净 */
    p->blocking = 0U;
    p->released_abnormal = 1U;
    p->session_dead = 1U;
    p->readable = 1U;
    p->send_ready = 0U;
    p->event_cb = (net_event_cb_t)0x1234;
    /* 这里刻意用 netTask 直调版（net_close_sock）而不是公开 net_close：
     * 本场景没绑消息队列，公开入口会先撞上"队列未创建"的 NET_ERR，
     * 而那属于分片 3 的断言面（TC-NETSOCK-110h）。close 的清零主路径在 net_close_locked。 */
    CHECK(net_close_sock(&s_net_socks[fd]) == 0,
          "TC-NETSOCK-104i net_close_sock 成功（close 的 memset 是清零主路径）");
    fd = net_socket(NET_AF_INET, NET_SOCK_STREAM);
    p = &s_net_socks[fd];
    CHECK(fd == 0 && p->blocking == 1U && p->released_abnormal == 0U &&
          p->session_dead == 0U && p->readable == 0U && p->send_ready == 1U &&
          p->event_cb == NULL,
          "TC-NETSOCK-104j 复用同一槽位：残留字段全部不得带走");
    /* 地址族不支持 → INVAL（在 alloc 之前，不占槽） */
    CHECK(net_socket(NET_AF_INET6, NET_SOCK_STREAM) == -1 &&
          net_get_errno() == NET_ERR_INVAL && s_net_socks[1].in_use == 0U,
          "TC-NETSOCK-104k 非 INET 地址族 → INVAL 且不占槽位");

    reset_all();
}

static void tc_105_bind(void)
{
    struct net_sockaddr_in in;
    int fd;
    int rc;

    reset_all();

    (void)memset(&in, 0, sizeof(in));
    in.sin_family = NET_AF_INET;
    in.sin_port = net_htons(2404);
    in.sin_addr.s_addr = net_inet_addr("192.168.1.100");

    CHECK(net_bind(-1, (struct net_sockaddr *)&in, sizeof(in)) == -1 &&
          net_get_errno() == NET_ERR_BADF, "TC-NETSOCK-105a 越界 fd → BADF");
    CHECK(net_bind(0, (struct net_sockaddr *)&in, sizeof(in)) == -1 &&
          net_get_errno() == NET_ERR_BADF, "TC-NETSOCK-105b 未创建就 bind → BADF");

    fd = net_socket(NET_AF_INET, NET_SOCK_STREAM);
    CHECK(net_bind(fd, NULL, sizeof(in)) == -1 && net_get_errno() == NET_ERR_INVAL,
          "TC-NETSOCK-105c addr 为 NULL → INVAL");
    CHECK(net_bind(fd, (struct net_sockaddr *)&in, 1) == -1 &&
          net_get_errno() == NET_ERR_INVAL, "TC-NETSOCK-105d addrlen 不足 → INVAL");
    CHECK(net_bind(fd, (struct net_sockaddr *)&in, sizeof(in)) == 0,
          "TC-NETSOCK-105e TCP bind 成功");
    CHECK(s_net_socks[fd].local_port == 2404U &&
          s_net_socks[fd].state == NET_SOCK_STATE_BOUND,
          "TC-NETSOCK-105f TCP 只记端口转主机序 + 进 BOUND，不碰芯片");
    CHECK(g_chip.set_port_calls == 0 && g_chip.open_calls == 0,
          "TC-NETSOCK-105g TCP bind 期间不得下发源端口/开芯片 Socket（打开留给 listen）");

    /* port=0 → 动态端口 49152 起，并推进 */
    reset_all();
    (void)memset(&in, 0, sizeof(in));
    in.sin_port = 0U;
    fd = net_socket(NET_AF_INET, NET_SOCK_STREAM);
    rc = net_bind(fd, (struct net_sockaddr *)&in, sizeof(in));
    CHECK(rc == 0 && s_net_socks[fd].local_port == 49152U,
          "TC-NETSOCK-105h port=0 → 分配 49152");
    CHECK(s_dynamic_port == 49153U,
          "TC-NETSOCK-105h2 计数器已推进到 49153（分配即推进，不留重复）");
    (void)net_socket(NET_AF_INET, NET_SOCK_STREAM);      /* 只创建不 bind */
    CHECK(s_dynamic_port == 49153U,
          "TC-NETSOCK-105i3 创建 socket **不**消耗动态端口（只有 bind 消耗）");
    fd = net_socket(NET_AF_INET, NET_SOCK_STREAM);
    rc = net_bind(fd, (struct net_sockaddr *)&in, sizeof(in));
    CHECK(rc == 0 && s_net_socks[fd].local_port == 49153U && s_dynamic_port == 49154U,
          "TC-NETSOCK-105i 第二次 bind 拿下一个端口（不会把同一个端口发两次）");

    /* 回绕：把计数器压到 65535，分配后应回 49152（不是 0——0 会让芯片按"未绑定"处理） */
    s_dynamic_port = 65535U;
    reset_all();
    s_dynamic_port = 65535U;
    fd = net_socket(NET_AF_INET, NET_SOCK_STREAM);
    rc = net_bind(fd, (struct net_sockaddr *)&in, sizeof(in));
    CHECK(rc == 0 && s_net_socks[fd].local_port == 65535U && s_dynamic_port == 49152U,
          "TC-NETSOCK-105j 动态端口越过 65535 回绕到 49152（不回 0）");
}

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

    reset_all();
    (void)memset(&in, 0, sizeof(in));
    in.sin_family = NET_AF_INET;
    in.sin_port = net_htons(8888);

    /* UDP：bind 就直接开芯片侧（无监听态），且必须配 DesIP=255.255.255.255 收任意源 */
    fd = net_socket(NET_AF_INET, NET_SOCK_DGRAM);
    CHECK(net_bind(fd, (struct net_sockaddr *)&in, sizeof(in)) == 0, "TC-NETSOCK-106a UDP bind 成功");
    CHECK(s_net_socks[fd].state == NET_SOCK_STATE_UDP_OPEN, "TC-NETSOCK-106b UDP 直接进 UDP_OPEN");
    CHECK(g_chip.set_proto_calls == 1 && g_chip.last_proto == CH395F_PROTO_TYPE_UDP,
          "TC-NETSOCK-106c 协议下发为 UDP（不是 TCP）");
    CHECK(g_chip.set_port_calls == 1 && g_chip.last_port == 8888U,
          "TC-NETSOCK-106d 源端口随 bind 下发");
    CHECK(g_fx.des_ip[0][0] == 0xFFU && g_fx.des_ip[0][1] == 0xFFU &&
          g_fx.des_ip[0][2] == 0xFFU && g_fx.des_ip[0][3] == 0xFFU &&
          g_fx.des_port[0] == 0U,
          "TC-NETSOCK-106e UDP Server 模式：DesIP=全 FF + 目的端口 0（否则只收单一对端）");
    CHECK(g_chip.open_calls == 1, "TC-NETSOCK-106f UDP bind 开一次芯片 Socket");

    /* 槽位 >=4 必须补设收发缓冲（net_init 已配过，这里是兜底）：布局 6 块/槽 */
    reset_all();
    fd = net_socket(NET_AF_INET, NET_SOCK_DGRAM);
    CHECK(fd == 0, "TC-NETSOCK-106g 先拿 fd0（对照：不补缓冲）");
    CHECK(g_fxchip.set_recv_buf_calls == 0, "TC-NETSOCK-106h fd<4 的 UDP bind 不重设缓冲");

    reset_all();
    for (fd = 0; fd < 4; fd++) {
        (void)net_socket(NET_AF_INET, NET_SOCK_DGRAM);
    }
    fd = net_socket(NET_AF_INET, NET_SOCK_DGRAM);      /* fd4 */
    (void)net_bind(fd, (struct net_sockaddr *)&in, sizeof(in));
    CHECK(g_fx.recv_blk_start[4] == (uint8_t)(4 * 6) &&
          g_fx.recv_blk_cnt[4] == (uint8_t)CH395F_RECV_BLOCKS &&
          g_fx.send_blk_start[4] == (uint8_t)(4 * 6 + (int)CH395F_RECV_BLOCKS) &&
          g_fx.send_blk_cnt[4] == (uint8_t)CH395F_SEND_BLOCKS,
          "TC-NETSOCK-106i fd>=4 兜底重设收发缓冲，块布局与 net_init 同构（6 块/槽）");

    /* open 失败 → BUSY 且留在原状态（不得谎报 UDP_OPEN） */
    reset_all();
    fd = net_socket(NET_AF_INET, NET_SOCK_DGRAM);
    g_fake.open_rc[fd] = CH395F_ERR_USE;
    CHECK(net_bind(fd, (struct net_sockaddr *)&in, sizeof(in)) == -1 &&
          net_get_errno() == NET_ERR_BUSY &&
          s_net_socks[fd].state != NET_SOCK_STATE_UDP_OPEN &&
          g_ns_error_count == 1,
          "TC-NETSOCK-106j UDP open 失败 → BUSY + 留痕 + 状态不前进");
}

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

    reset_all();
    (void)net_init("192.168.1.100", "255.255.255.0", "192.168.1.1", NULL);

    CHECK(net_getsockname(-1, sa, &addrlen) == -1 && net_get_errno() == NET_ERR_BADF,
          "TC-NETSOCK-107a getsockname 越界 → BADF");
    CHECK(net_getsockname(0, sa, &addrlen) == -1 && net_get_errno() == NET_ERR_BADF,
          "TC-NETSOCK-107b 未用且 CLOSED 的槽 → BADF");

    fd = net_socket(NET_AF_INET, NET_SOCK_STREAM);
    (void)memset(&in, 0, sizeof(in));
    in.sin_port = net_htons(7003);
    CHECK(net_bind(fd, sa, (int)sizeof(in)) == 0, "TC-NETSOCK-107c bind 前置成功");
    addrlen = (int)sizeof(in);
    (void)memset(&in, 0, sizeof(in));
    CHECK(net_getsockname(fd, sa, &addrlen) == 0, "TC-NETSOCK-107d getsockname 成功");
    CHECK(in.sin_family == NET_AF_INET && net_ntohs(in.sin_port) == 7003U &&
          addrlen == (int)sizeof(in),
          "TC-NETSOCK-107e 回填族/端口(网络序)/长度");
    /* 钉**具体顺位**而不是二选一：getsockname 走的是「首段在最低字节」这一族
     * （与 net_inet_ntoa、net_events 的 remote_ip 同族），所以 192.168.1.100 =
     * 0x6401A8C0。net_inet_addr 返回的是另一族（首段在最高字节，0xC0A80164），
     * 两族不互逆——已作为疑似缺陷报出，这里刻意不写成「两个都行」。 */
    CHECK(in.sin_addr.s_addr == 0x6401A8C0U,
          "TC-NETSOCK-107f 本机 IP 顺位=首段在最低字节（与 ntoa 同族；net_inet_addr 是另一族）");

    addrlen = 1;
    CHECK(net_getsockname(fd, sa, &addrlen) == -1 && net_get_errno() == NET_ERR_INVAL,
          "TC-NETSOCK-107g 长度不足 → INVAL");
    CHECK(net_getsockname(fd, sa, NULL) == -1 && net_get_errno() == NET_ERR_INVAL,
          "TC-NETSOCK-107h addrlen 为 NULL → INVAL");

    /* getpeername：没有 CONNECT 回读过对端 → NOTCONN（不发 SPI 是它的卖点） */
    (void)memset(&in, 0, sizeof(in));
    addrlen = (int)sizeof(in);
    CHECK(net_getpeername(fd, sa, &addrlen) == -1 && net_get_errno() == NET_ERR_NOTCONN,
          "TC-NETSOCK-107i 尚无对端 → NOTCONN（remote_port==0 判据）");
    CHECK(g_chip.get_status_calls == 0 && g_fxchip.glob_calls == 0,
          "TC-NETSOCK-107j getpeername 纯读缓存，不发任何芯片事务");

    s_net_socks[fd].remote_port = 51999U;
    s_net_socks[fd].remote_ip = 0x0B01A8C0U;
    (void)memset(&in, 0, sizeof(in));
    addrlen = (int)sizeof(in);
    CHECK(net_getpeername(fd, sa, &addrlen) == 0 &&
          net_ntohs(in.sin_port) == 51999U && in.sin_addr.s_addr == 0x0B01A8C0U &&
          in.sin_family == NET_AF_INET,
          "TC-NETSOCK-107k getpeername 回填缓存的对端 IP:端口");
    CHECK(net_getpeername(-1, sa, &addrlen) == -1 && net_get_errno() == NET_ERR_BADF,
          "TC-NETSOCK-107l getpeername 越界 → BADF");
    CHECK(net_getpeername(5, sa, &addrlen) == -1 && net_get_errno() == NET_ERR_BADF,
          "TC-NETSOCK-107m getpeername 未在用 → BADF");
    addrlen = 2;
    CHECK(net_getpeername(fd, sa, &addrlen) == -1 && net_get_errno() == NET_ERR_INVAL,
          "TC-NETSOCK-107n getpeername 长度不足 → INVAL");

    reset_all();
}

static void tc_108_sockprops(void)
{
    int fd;
    int arg = 7;

    reset_all();
    CHECK(net_setblocking(-1, 1) == -1 && net_get_errno() == NET_ERR_BADF,
          "TC-NETSOCK-108a setblocking 越界 → BADF");
    CHECK(net_setblocking(0, 1) == -1 && net_get_errno() == NET_ERR_BADF,
          "TC-NETSOCK-108b 未占用 → BADF");
    CHECK(net_set_event_cb(-1, NULL, NULL) == -1 && net_get_errno() == NET_ERR_BADF,
          "TC-NETSOCK-108c set_event_cb 越界 → BADF");
    CHECK(net_set_event_cb(0, NULL, NULL) == -1 && net_get_errno() == NET_ERR_BADF,
          "TC-NETSOCK-108d set_event_cb 未占用 → BADF");

    fd = net_socket(NET_AF_INET, NET_SOCK_STREAM);
    CHECK(net_setblocking(fd, 0) == 0 && s_net_socks[fd].blocking == 0U,
          "TC-NETSOCK-108e setblocking(0) 落属性（模式挂控制块，不是单次参数）");
    CHECK(net_setblocking(fd, 5) == 0 && s_net_socks[fd].blocking == 1U,
          "TC-NETSOCK-108f 非 0 一律视为阻塞");
    CHECK(net_set_event_cb(fd, (net_event_cb_t)0x1234, &arg) == 0 &&
          s_net_socks[fd].event_cb == (net_event_cb_t)0x1234 &&
          s_net_socks[fd].event_arg == &arg,
          "TC-NETSOCK-108g 注册回调与用户参数");
    CHECK(net_set_event_cb(fd, NULL, NULL) == 0 && s_net_socks[fd].event_cb == NULL,
          "TC-NETSOCK-108h cb=NULL 取消注册");
    s_net_socks[fd].state = NET_SOCK_STATE_ESTABLISHED;
    CHECK(net_sock_state(fd) == (int)NET_SOCK_STATE_ESTABLISHED,
          "TC-NETSOCK-108i sock_state 返状态快照");
    CHECK(net_sock_state(NET_MAX_SOCKETS) == -1, "TC-NETSOCK-108j sock_state 越界 -1");
    s_net_socks[fd].in_use = 0U;
    CHECK(net_sock_state(fd) == -1, "TC-NETSOCK-108k sock_state 未占用 -1");

    reset_all();
}

static void tc_109_generation(void)
{
    reset_all();
    CHECK(net_get_generation() == 0U, "TC-NETSOCK-109a 初值 0");
    net_generation_inc();
    net_generation_inc();
    CHECK(net_get_generation() == 2U, "TC-NETSOCK-109b 每次网络重建 +1（服务据此重建监听）");
    reset_all();
}

static void tc_110_queue_adopt(void)
{
    static int q1;
    static int q2;

    reset_all();
    CHECK(net_msg_queue_adopt(NULL) == -1, "TC-NETSOCK-110a 空句柄 → -1");
    CHECK(net_msg_queue_adopt((osMessageQueueId_t)&q1) == 0, "TC-NETSOCK-110b 首次绑定成功");
    CHECK(net_msg_queue_adopt((osMessageQueueId_t)&q2) == -1,
          "TC-NETSOCK-110c 重复绑定必须被拒（不静默换句柄）");
    CHECK(s_net_msg_queue == (osMessageQueueId_t)&q1,
          "TC-NETSOCK-110d 重复绑定**保留首次**句柄——换掉会让已入队请求永不处理");
    /* 未绑定时所有公开 API 一律 NET_ERR，而不是崩在空句柄上 */
    reset_all();
    CHECK(net_listen(0) == -1 && net_get_errno() == NET_ERR,
          "TC-NETSOCK-110e 未绑定队列：net_listen → NET_ERR");
    CHECK(net_recv(0, NULL, 0, 0) == -1 && net_get_errno() == NET_ERR,
          "TC-NETSOCK-110f 未绑定队列：net_recv → NET_ERR（越界检查在队检查之前）");
    CHECK(net_send(0, "x", 1, 0) == -1 && net_get_errno() == NET_ERR,
          "TC-NETSOCK-110g 未绑定队列：net_send → NET_ERR");
    CHECK(net_close(0) == -1 && net_get_errno() == NET_ERR,
          "TC-NETSOCK-110h 未绑定队列：net_close → NET_ERR");
    CHECK(net_drop_conn(0) == -1 && net_get_errno() == NET_ERR,
          "TC-NETSOCK-110i 未绑定队列：net_drop_conn → NET_ERR");
    CHECK(net_recv_to(0, NULL, 0, 10U) == -1 && net_get_errno() == NET_ERR,
          "TC-NETSOCK-110j 未绑定队列：net_recv_to → NET_ERR");
    CHECK(net_accept(0, NULL, NULL) == -1 && net_get_errno() == NET_ERR,
          "TC-NETSOCK-110k 未绑定队列：net_accept → NET_ERR");
    CHECK(net_connect(0, NULL, 0) == -1 && net_get_errno() == NET_ERR,
          "TC-NETSOCK-110l 未绑定队列：net_connect → NET_ERR");
    /* 越界优先于"未初始化"：调用方拿到的码要能区分"我传错了"和"网还没起来" */
    CHECK(net_send(NET_MAX_SOCKETS, "x", 1, 0) == -1 && net_get_errno() == NET_ERR_BADF,
          "TC-NETSOCK-110m 越界检查先于队列检查 → BADF");
    reset_all();
}

/* ===================== 分片 2 每任务错误码槽（E-03） ===================== */

static void tc_120_errno_slot_per_task(void)
{
    reset_all();

    /* 内核没跑起来：不做槽位分配，一律退到 [0] 槽（中断/内核前上下文） */
    g_ns_kernel_state = osKernelInactive;
    g_ns_cur_task = (TaskHandle_t)&g_ns_task_caller;
    (void)net_set_errno(NET_ERR_BADF);
    CHECK(net_get_errno() == NET_ERR_BADF && s_net_errno_slots[0].owner == NULL,
          "TC-NETSOCK-120a 内核未运行 → 用 [0] 槽且**不占槽**（不写 owner）");
    g_ns_cur_task = (TaskHandle_t)&g_ns_task_net;
    CHECK(net_get_errno() == NET_ERR_BADF,
          "TC-NETSOCK-120b 内核未运行时所有任务共享 [0] 槽（退化语义）");

    /* 内核在跑：每个任务自己的槽位 */
    g_ns_kernel_state = osKernelRunning;
    reset_all();
    g_ns_kernel_state = osKernelRunning;
    g_ns_cur_task = (TaskHandle_t)&g_ns_task_caller;
    (void)net_set_errno(NET_ERR_TIMEDOUT);
    g_ns_cur_task = (TaskHandle_t)&g_ns_task_net;
    CHECK(net_get_errno() == NET_OK,
          "TC-NETSOCK-120c 另一个任务读不到 caller 的码（E-03 的正面表述）");
    (void)net_set_errno(NET_ERR_WOULDBLOCK);
    CHECK(net_get_errno() == NET_ERR_WOULDBLOCK, "TC-NETSOCK-120d 本任务读自己的码");
    g_ns_cur_task = (TaskHandle_t)&g_ns_task_caller;
    CHECK(net_get_errno() == NET_ERR_TIMEDOUT,
          "TC-NETSOCK-120e 互不覆写：caller 的码没被 netTask 抢走（旧实现的红线）");
    /* 临界区：两个任务各占一次槽 → 两次进入、两次退出，绝不泄漏嵌套计数 */
    CHECK(g_ns_crit_enter == 2 && g_ns_crit_exit == 2 && ns_os_crit_depth() == 0,
          "TC-NETSOCK-120f 每次**首次占槽**进一次临界区且成对退出（无泄漏）");

    /* 快路径只读不写：已有槽位的任务反复读写都不该再进临界区、也不该再占槽 */
    {
        int e0 = g_ns_crit_enter;
        int owners0 = ns_slot_owner_count();
        int i_caller = ns_slot_index_of((TaskHandle_t)&g_ns_task_caller);
        int i_net = ns_slot_index_of((TaskHandle_t)&g_ns_task_net);

        CHECK(i_caller >= 0 && i_net >= 0 && i_caller != i_net,
              "TC-NETSOCK-120g 两个任务落在**不同**槽位（槽位表可查，不是靠约定）");
        g_ns_cur_task = (TaskHandle_t)&g_ns_task_caller;
        (void)net_set_errno(NET_ERR_BUSY);
        (void)net_get_errno();
        (void)net_set_errno(NET_ERR_CONNRESET);
        CHECK(g_ns_crit_enter == e0, "TC-NETSOCK-120h 命中已有槽位：全程零临界区（快路径只读）");
        g_ns_cur_task = (TaskHandle_t)&g_ns_task_net;
        CHECK(net_get_errno() == NET_ERR_WOULDBLOCK &&
              ns_slot_owner_count() == owners0,
              "TC-NETSOCK-120i 别的任务反复读也不新增槽位、也读不到 caller 的码");
        g_ns_cur_task = (TaskHandle_t)&g_ns_task_caller;
        CHECK(net_get_errno() == NET_ERR_CONNRESET, "TC-NETSOCK-120j caller 读到自己最新的码");
    }

    /* 槽位用尽 → 回退 [0]（刻意不重试，避免把竞态带回来） */
    reset_all();
    g_ns_kernel_state = osKernelRunning;
    {
        int i;
        static int filler[10];
        for (i = 0; i < (int)NET_ERRNO_TASK_SLOTS; i++) {
            g_ns_cur_task = (TaskHandle_t)&filler[i];
            (void)net_set_errno(NET_ERR_ISCONN);
        }
        g_ns_cur_task = (TaskHandle_t)&filler[0];
        CHECK(net_get_errno() == NET_ERR_ISCONN, "TC-NETSOCK-120k 8 个槽各归各主");
        g_ns_cur_task = (TaskHandle_t)&g_ns_task_caller;      /* 第 9 个任务 */
        (void)net_set_errno(NET_ERR_NOMEM);
        CHECK(net_get_errno() == NET_ERR_NOMEM,
              "TC-NETSOCK-120l 槽位用尽：新任务落 [0] 槽仍读得到自己的码");
        g_ns_cur_task = (TaskHandle_t)&filler[0];
        CHECK(net_get_errno() == NET_ERR_NOMEM,
              "TC-NETSOCK-120m 用尽后退化为共享 [0] 槽（只影响排障可读性，不新增共享槽位）");
    }
    reset_all();
}

static void tc_121_errno_slot_isr(void)
{
    reset_all();
    g_ns_kernel_state = osKernelRunning;
    g_ns_cur_task = NULL;                 /* 中断上下文/无句柄 */
    (void)net_set_errno(NET_ERR_CONNRESET);
    CHECK(net_get_errno() == NET_ERR_CONNRESET && s_net_errno_slots[0].owner == NULL,
          "TC-NETSOCK-121 句柄为 NULL（中断上下文）→ 退 [0] 槽且不改槽位表");
    reset_all();
}

/* ===================== 主入口 ===================== */

int main(void)
{
    printf("=== NET Socket Tests (net_socket.c 主机单测) ===\n");

    printf("[shard1] 纯函数面与 fd 表\n");
    tc_100_inet_helpers();
    tc_101_byteorder();
    tc_102_parse_ip();
    tc_103_alloc_and_getsock();
    tc_104_socket_no_inherit();
    tc_105_bind();
    tc_106_bind_udp();
    tc_107_peer_and_localname();
    tc_108_sockprops();
    tc_109_generation();
    tc_110_queue_adopt();

    printf("[shard2] 每任务错误码槽 + 队列绑定\n");
    tc_120_errno_slot_per_task();
    tc_121_errno_slot_isr();

    printf("[shard3] 跨上下文消息与通知值回传\n");
    ns_run_s3();

    printf("[shard4] 状态机与闸门\n");
    ns_run_s4();

    printf("[shard5] 建流与读写分支\n");
    ns_run_s5();

    printf("[shard6] 边界残支与其余出口\n");
    ns_run_s6();

    printf("=== NET Socket Tests: %d/%d PASSED (failed=%d) ===\n",
           s_passed, s_total, s_failed);
    return (s_failed == 0) ? 0 : 1;
}