STM32F4-Base/test/host/common/ch395f_fake.c

/*
 * 模块名称：假 CH395F 芯片实现（NET 域主机侧单测共享件）
 * 模块功能：实现 ch395f_fake.h 声明的假芯片。由测试单元 #include 本 .c 使用
 *           （本仓主机单测的既有做法：生产源与假件都进同一个 TU）。
 * 创建日期：2026-10-23
 */

#include <string.h>

#include "ch395f_fake.h"

ch395f_fake_world_t g_fake;
ch395f_fake_obs_t   g_chip;

static void fake_log(char c)
{
    if (g_chip.log_n < (CH395F_FAKE_LOG_LEN - 1)) {
        g_chip.log[g_chip.log_n++] = c;
        g_chip.log[g_chip.log_n] = '\0';
    }
}

void ch395f_fake_reset(void)
{
    int i;

    (void)memset(&g_fake, 0, sizeof(g_fake));
    (void)memset(&g_chip, 0, sizeof(g_chip));
    for (i = 0; i < CH395F_FAKE_SOCK_MAX; i++) {
        g_fake.cached_open[i] = CH395F_SOCKET_CLOSED;
        g_fake.cached_tcp[i] = CH395F_TCP_CLOSED;
        g_fake.status_byte0[i] = CH395F_SOCKET_CLOSED;
        g_fake.status_byte1[i] = CH395F_TCP_CLOSED;
        g_fake.link_up = 1U;
        g_fake.open_rc[i] = CH395F_ERR_SUCCESS;
        g_fake.listen_rc[i] = CH395F_ERR_SUCCESS;
    }
}

void ch395f_fake_push_recv_len(uint8_t sock, uint16_t v)
{
    if ((sock < CH395F_FAKE_SOCK_MAX) &&
        (g_fake.recv_len_n[sock] < CH395F_FAKE_QUEUE_LEN)) {
        g_fake.recv_len_q[sock][g_fake.recv_len_n[sock]++] = v;
    }
}

void ch395f_fake_set_peer(uint8_t sock, uint8_t b0, uint8_t b1, uint8_t b2,
                          uint8_t b3, uint16_t peer_port)
{
    if (sock >= CH395F_FAKE_SOCK_MAX) {
        return;
    }
    g_fake.remote[sock][0] = b0;
    g_fake.remote[sock][1] = b1;
    g_fake.remote[sock][2] = b2;
    g_fake.remote[sock][3] = b3;
    g_fake.remote[sock][4] = (uint8_t)(peer_port & 0xFFU);
    g_fake.remote[sock][5] = (uint8_t)((peer_port >> 8) & 0xFFU);
}

void ch395f_fake_set_listening(uint8_t sock)
{
    if (sock < CH395F_FAKE_SOCK_MAX) {
        g_fake.cached_open[sock] = CH395F_SOCKET_OPEN;
        g_fake.cached_tcp[sock] = CH395F_TCP_LISTEN;
    }
}

ch395f_sock_state_t ch395f_sock_state_cached(uint8_t sn)
{
    ch395f_sock_state_t s;

    g_chip.cached_calls++;
    g_chip.last_sock = sn;
    s.open = (sn < CH395F_FAKE_SOCK_MAX) ? g_fake.cached_open[sn] : CH395F_SOCKET_CLOSED;
    s.tcp_state = (sn < CH395F_FAKE_SOCK_MAX) ? g_fake.cached_tcp[sn] : CH395F_TCP_CLOSED;
    return s;
}

ch395f_sock_state_t ch395f_get_sock_state(uint8_t sn)
{
    return ch395f_sock_state_cached(sn);
}

void ch395f_get_socket_status(uint8_t sock, uint8_t *status)
{
    g_chip.get_status_calls++;
    g_chip.last_sock = sock;
    fake_log('s');
    if (status != NULL) {
        status[0] = (sock < CH395F_FAKE_SOCK_MAX) ? g_fake.status_byte0[sock] : CH395F_SOCKET_CLOSED;
        status[1] = (sock < CH395F_FAKE_SOCK_MAX) ? g_fake.status_byte1[sock] : CH395F_TCP_CLOSED;
    }
}

/* 整体读即清：返回后该 socket 的挂起位图清零（真实芯片没有按位清除手段） */
uint8_t ch395f_get_sock_int_status(uint8_t sock)
{
    uint8_t v = 0U;

    g_chip.int_status_calls++;
    g_chip.last_sock = sock;
    fake_log('i');
    if (sock < CH395F_FAKE_SOCK_MAX) {
        v = g_fake.int_status[sock];
        g_fake.int_status[sock] = 0U;
    }
    return v;
}

uint16_t ch395f_get_recv_len(uint8_t sock)
{
    uint16_t v;

    g_chip.last_sock = sock;
    fake_log('R');
    if ((sock >= CH395F_FAKE_SOCK_MAX) || (g_fake.recv_len_n[sock] == 0)) {
        return 0U;
    }
    /* 按调用序号取；耗尽后回落最后一个值（便于表达"一直有数据"的持续态） */
    if (g_fake.recv_len_i[sock] < g_fake.recv_len_n[sock]) {
        v = g_fake.recv_len_q[sock][g_fake.recv_len_i[sock]++];
    } else {
        v = g_fake.recv_len_q[sock][g_fake.recv_len_n[sock] - 1];
    }
    return v;
}

void ch395f_read_recv_buf(uint8_t sock, uint8_t *p_data, uint16_t len)
{
    g_chip.read_calls++;
    g_chip.last_sock = sock;
    g_chip.last_read_len = len;
    fake_log('r');
    if ((p_data != NULL) && (len > 0U)) {
        (void)memset(p_data, 0, len);        /* 交出去的是零，测试不依赖内容 */
    }
}

void ch395f_write_send_buf(uint8_t sock, uint8_t *p_data, uint16_t len)
{
    (void)p_data;
    g_chip.write_calls++;
    g_chip.last_sock = sock;
    g_chip.last_read_len = len;
    fake_log('w');
}

uint8_t ch395f_open_socket(uint8_t sock)
{
    g_chip.open_calls++;
    g_chip.last_sock = sock;
    fake_log('o');
    return (sock < CH395F_FAKE_SOCK_MAX) ? g_fake.open_rc[sock] : 0x01U;
}

uint8_t ch395f_close_socket(uint8_t sock)
{
    g_chip.close_calls++;
    g_chip.last_sock = sock;
    fake_log('c');
    return CH395F_ERR_SUCCESS;
}

uint8_t ch395f_tcp_listen(uint8_t sock)
{
    g_chip.listen_calls++;
    g_chip.last_sock = sock;
    fake_log('l');
    return (sock < CH395F_FAKE_SOCK_MAX) ? g_fake.listen_rc[sock] : 0x01U;
}

void ch395f_set_proto_type(uint8_t sock, uint8_t proto)
{
    g_chip.set_proto_calls++;
    g_chip.last_sock = sock;
    g_chip.last_proto = proto;
    fake_log('P');
}

void ch395f_set_sour_port(uint8_t sock, uint16_t port)
{
    g_chip.set_port_calls++;
    g_chip.last_sock = sock;
    g_chip.last_port = port;
    fake_log('p');
}

void ch395f_get_remot_ipp(uint8_t sock, uint8_t *p_buf)
{
    if (p_buf == NULL) {
        return;
    }
    if (sock < CH395F_FAKE_SOCK_MAX) {
        (void)memcpy(p_buf, g_fake.remote[sock], 6U);
    } else {
        (void)memset(p_buf, 0, 6U);
    }
}

void ch395f_set_keepalive_enable(uint8_t sock, uint8_t enable)
{
    g_chip.keepalive_calls++;
    g_chip.last_sock = sock;
    g_chip.last_keepalive = enable;
}

uint8_t ch395f_link_up_cached(void)
{
    return g_fake.link_up;
}

uint16_t ch395f_link_change_count(void)
{
    return g_fake.link_change;
}