#define _GNU_SOURCE

/* test_audiod_host.c — meow_audiod 宿主集成测试（FILE sink，无 /dev/snd 环境）。
 *
 * 验证 AUDIOD_DESIGN.md 里程碑 A1：
 *   - 全 IPC 链路：OPEN→WRITE→QUERY→PAUSE/RESUME→STOP→EOF 回收
 *   - 两个客户端抢占：旧流收 MSG_AUDIO_PREEMPTED（PCM 丢弃）
 *   - tone 生成 WAV 可核验正弦（440Hz，帧数/过零率粗检）
 *
 * 启动被测试 audiod（宿主二进制，env MEOW_AUDIO_SINK=file / MEOW_AUDIO_OUT=<wav> /
 * MEOW_AUDIO_SOCK=<sock> / MEOW_AUDIO_FORCE=1 跳过门控）。
 *
 * 编译（宿主）：cc -I../meow_launcherd -Os -Wall -Wextra test_audiod_host.c -o test_audiod_host
 */
#include "meow_ipc.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <fcntl.h>
#include <math.h>
#include <poll.h>
#include <signal.h>
#include <time.h>
#include <sys/time.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <sys/wait.h>
#include <sys/stat.h>

#define TSOCK "/tmp/meow_audio_test.sock"
#define TWAV  "/tmp/meow_audio_test.wav"

static int   g_audiod_pid = -1;
static int   g_pass = 0, g_fail = 0;

static void check(int cond, const char *name)
{
    if (cond) { printf("  PASS %s\n", name); g_pass++; }
    else      { printf("  FAIL %s\n", name); g_fail++; }
}

/* ---- 原始 IPC 客户端（全有界：connect 非阻塞 2s + SO_SNDTIMEO 2s——回归卡死时
 * 测试 FAIL 而不是跟着挂死） ---- */
struct cli { int fd; };
static int cli_connect(struct cli *c)
{
    c->fd = socket(AF_UNIX, SOCK_STREAM, 0);
    if (c->fd < 0) return -1;
    int fl = fcntl(c->fd, F_GETFL, 0);
    if (fl >= 0) fcntl(c->fd, F_SETFL, fl | O_NONBLOCK);
    struct sockaddr_un a;
    memset(&a, 0, sizeof a);
    a.sun_family = AF_UNIX;
    snprintf(a.sun_path, sizeof a.sun_path, "%s", TSOCK);
    int r = connect(c->fd, (struct sockaddr *)&a, sizeof a);
    if (r < 0 && errno == EINPROGRESS) {
        struct pollfd p;
        p.fd = c->fd; p.events = POLLOUT; p.revents = 0;
        if (poll(&p, 1, 2000) > 0) {
            int err = 0;
            socklen_t el = sizeof err;
            if (getsockopt(c->fd, SOL_SOCKET, SO_ERROR, &err, &el) == 0 && err != 0) { errno = err; r = -1; }
        } else {
            r = -1;
        }
    }
    if (r < 0) { close(c->fd); return -1; }
    if (fl >= 0) fcntl(c->fd, F_SETFL, fl);
    struct timeval tv;
    tv.tv_sec = 2; tv.tv_usec = 0;
    setsockopt(c->fd, SOL_SOCKET, SO_SNDTIMEO, &tv, sizeof tv);
    return 0;
}
static int w_all(int fd, const void *p, size_t n)
{
    const uint8_t *b = p; size_t o = 0;
    while (o < n) { ssize_t r = write(fd, b + o, n - o); if (r < 0) { if (errno == EINTR) continue; return -1; } o += (size_t)r; }
    return 0;
}
static int r_all(int fd, void *p, size_t n)
{
    uint8_t *b = p; size_t o = 0;
    while (o < n) { ssize_t r = read(fd, b + o, n - o); if (r <= 0) return -1; o += (size_t)r; }
    return 0;
}
static int sf(int fd, uint16_t type, uint32_t req, const void *pl, uint32_t len)
{
    uint8_t hdr[MEOW_IPC_HDR_LEN];
    uint32_t magic = MEOW_IPC_MAGIC; uint16_t ver = MEOW_IPC_VERSION;
    memcpy(hdr, &magic, 4); memcpy(hdr + 4, &ver, 2); memcpy(hdr + 6, &type, 2); memcpy(hdr + 8, &req, 4); memcpy(hdr + 12, &len, 4);
    if (w_all(fd, hdr, sizeof hdr)) return -1;
    if (len && pl && w_all(fd, pl, len)) return -1;
    return 0;
}
static int rf(int fd, uint16_t *type, uint8_t *rbuf, uint32_t rcap)
{
    uint8_t hdr[MEOW_IPC_HDR_LEN];
    if (r_all(fd, hdr, sizeof hdr)) return -1;
    uint32_t magic, len; uint16_t ver;
    memcpy(&magic, hdr, 4); memcpy(&ver, hdr + 4, 2); memcpy(type, hdr + 6, 2); memcpy(&len, hdr + 12, 4);
    if (magic != MEOW_IPC_MAGIC || ver != MEOW_IPC_VERSION) return -1;
    if (len > rcap) len = rcap;
    if (len && r_all(fd, rbuf, len)) return -1;
    return (int)len;
}
/* 带超时读一帧（poll） */
static int rf_tmo(int fd, int tmo_ms, uint16_t *type, uint8_t *rbuf, uint32_t rcap)
{
    struct pollfd p; p.fd = fd; p.events = POLLIN; p.revents = 0;
    if (poll(&p, 1, tmo_ms) <= 0) return -2;
    return rf(fd, type, rbuf, rcap);
}

static void stop_audiod(void)
{
    if (g_audiod_pid > 0) { kill(g_audiod_pid, SIGTERM); waitpid(g_audiod_pid, NULL, 0); g_audiod_pid = -1; }
}

/* 带超时的停止：SIGTERM 后最多等 tmo_ms；不退 → SIGKILL 并返回 0（卡死回归显形）。 */
static int stop_audiod_tmo(int tmo_ms)
{
    if (g_audiod_pid <= 0) return 1;
    kill(g_audiod_pid, SIGTERM);
    int ok = 0;
    for (int i = 0; i < tmo_ms / 50; i++) {
        if (waitpid(g_audiod_pid, NULL, WNOHANG) == g_audiod_pid) { ok = 1; break; }
        usleep(50000);
    }
    if (!ok) { kill(g_audiod_pid, SIGKILL); waitpid(g_audiod_pid, NULL, 0); }
    g_audiod_pid = -1;
    return ok;
}

static int start_audiod_ex(const char *sink, const char *wedge_after, const char *ring_wait_ms)
{
    pid_t pid = fork();
    if (pid == 0) {
        setenv("MEOW_AUDIO_SINK", sink, 1);
        setenv("MEOW_AUDIO_OUT", TWAV, 1);
        setenv("MEOW_AUDIO_SOCK", TSOCK, 1);
        setenv("MEOW_AUDIO_FORCE", "1", 1);
        if (wedge_after) setenv("MEOW_AUDIO_TEST_WEDGE_AFTER_BYTES", wedge_after, 1);
        if (ring_wait_ms) setenv("MEOW_AUDIO_RING_WAIT_MS", ring_wait_ms, 1);
        execl("./meow_audiod_host", "meow_audiod_host", (char *)0);
        _exit(127);
    }
    return pid;
}

static int start_audiod(void)
{
    return start_audiod_ex("file", NULL, NULL);
}

/* 带自定义 settings.conf 的启动（P2 蓝牙：测 audio.output_bt / bt.codec 读取生效） */
static int start_audiod_settings(const char *sink, const char *settings_path)
{
    pid_t pid = fork();
    if (pid == 0) {
        setenv("MEOW_AUDIO_SINK", sink, 1);
        setenv("MEOW_AUDIO_OUT", TWAV, 1);
        setenv("MEOW_AUDIO_SOCK", TSOCK, 1);
        setenv("MEOW_AUDIO_FORCE", "1", 1);
        if (settings_path) setenv("MEOW_AUDIO_SETTINGS", settings_path, 1);
        execl("./meow_audiod_host", "meow_audiod_host", (char *)0);
        _exit(127);
    }
    return pid;
}

/* 带 amixer 追踪的启动（A3/DSD：断言「音量双组写」PCM+DSD_VOLUME 成对下发）。settings_path 可空。 */
static int start_audiod_trace(const char *sink, const char *settings_path, const char *trace_path)
{
    pid_t pid = fork();
    if (pid == 0) {
        setenv("MEOW_AUDIO_SINK", sink, 1);
        setenv("MEOW_AUDIO_OUT", TWAV, 1);
        setenv("MEOW_AUDIO_SOCK", TSOCK, 1);
        setenv("MEOW_AUDIO_FORCE", "1", 1);
        if (settings_path) setenv("MEOW_AUDIO_SETTINGS", settings_path, 1);
        if (trace_path) setenv("MEOW_AUDIO_AMIXER_TRACE", trace_path, 1);
        execl("./meow_audiod_host", "meow_audiod_host", (char *)0);
        _exit(127);
    }
    return pid;
}

/* 直接客户端 open（带 flags：AUDIO_FLAG_DSD 用于 DoP） */
static int do_open_f(struct cli *c, int rate, int ch, int fmt, uint32_t flags, m_audio_open_ack_t *ack)
{
    m_audio_open_t o; memset(&o, 0, sizeof o);
    snprintf(o.app_id, sizeof o.app_id, "test");
    o.rate = (uint32_t)rate; o.ch = (uint16_t)ch; o.fmt = (uint16_t)fmt; o.flags = flags;
    if (sf(c->fd, MSG_AUDIO_OPEN, 1, &o, sizeof o)) return -1;
    uint8_t rbuf[256]; uint16_t rt;
    if (rf(c->fd, &rt, rbuf, sizeof rbuf) < 0) return -1;
    if (rt != MSG_AUDIO_OPEN_ACK) return -2;
    memcpy(ack, rbuf, sizeof *ack);
    return 0;
}
/* 直接客户端 open */
static int do_open(struct cli *c, int rate, int ch, int fmt, m_audio_open_ack_t *ack)
{
    return do_open_f(c, rate, ch, fmt, 0, ack);
}

static int do_write(struct cli *c, const void *pcm, uint32_t len)
{
    return sf(c->fd, MSG_AUDIO_WRITE, 0, pcm, len);
}
static int do_ctrl(struct cli *c, uint16_t type, uint32_t sid)
{
    m_audio_stream_t s; s.stream_id = sid;
    if (sf(c->fd, type, 2, &s, sizeof s)) return -1;
    uint8_t rbuf[64]; uint16_t rt;
    if (rf(c->fd, &rt, rbuf, sizeof rbuf) < 0) return -1;
    return (rt == MSG_ACK) ? 0 : -2;
}
static int do_query(struct cli *c, char *out, size_t n)
{
    if (sf(c->fd, MSG_AUDIO_QUERY, 3, NULL, 0)) return -1;
    uint8_t rbuf[MEOW_IPC_MAX]; uint16_t rt;
    int r = rf(c->fd, &rt, rbuf, sizeof rbuf);
    if (r < 0 || rt != MSG_AUDIO_STATE) return -1;
    size_t m = ((size_t)r < n - 1) ? (size_t)r : (n - 1);
    memcpy(out, rbuf, m);
    out[m] = 0;
    return 0;
}

/* 生成正弦 PCM（S16 or S32，stereo 交织），返回字节数 */
static size_t gen_sine(uint8_t *buf, size_t cap, int fmt, int frames, double freq, int rate)
{
    int bps = (fmt == AUDIO_FMT_S16) ? 2 : 4;
    size_t fs = 2;           /* 双声道 */
    size_t n = (frames > (int)(cap / (fs * bps))) ? (cap / (fs * bps)) : (size_t)frames;
    size_t o = 0;
    for (size_t i = 0; i < n; i++) {
        double ph = 2.0 * M_PI * freq * (double)i / (double)rate;
        int16_t s = (int16_t)(sin(ph) * 0.3 * 32767);
        for (int c = 0; c < 2; c++) {
            int32_t v = (fmt == AUDIO_FMT_S16) ? (int32_t)s : ((int32_t)s << 16);
            if (fmt == AUDIO_FMT_S16) { memcpy(buf + o, &s, 2); o += 2; }
            else { memcpy(buf + o, &v, 4); o += 4; }
        }
    }
    return o;
}

/* ---- WAV 校验：合法 + 近似正弦（逐帧过零/幅度粗检） ---- */
static int verify_wav(const char *path, int rate_expect, int ch_expect, int bits_expect)
{
    FILE *f = fopen(path, "rb");
    if (!f) return -1;
    unsigned char h[44];
    if (fread(h, 1, 44, f) != 44) { fclose(f); return -1; }
    if (memcmp(h, "RIFF", 4) || memcmp(h + 8, "WAVE", 4) || memcmp(h + 12, "fmt ", 4)) { fclose(f); return -1; }
    uint16_t ch, bits; uint32_t rate, byterate;
    memcpy(&ch, h + 22, 2); memcpy(&rate, h + 24, 4); memcpy(&byterate, h + 28, 4); memcpy(&bits, h + 34, 2);
    if (ch != ch_expect || rate != (uint32_t)rate_expect || bits != bits_expect) { fclose(f); return -1; }
    if (byterate != rate * ch * bits / 8) { fclose(f); return -1; }
    uint32_t data_len; memcpy(&data_len, h + 40, 4);
    if (data_len < 44) { fclose(f); return -1; }
    /* 读「左声道」样本（跳右声道）统计过零比例：正弦 freq@rate 单声道期望过零比例 ≈ 2*freq/rate。
     * 仅对「近似正弦」做粗检（40% 容差），确认不是静音/噪声/满幅方波。 */
    int bytes_samp = bits / 8;
    int frame_bytes = ch * bytes_samp;
    uint8_t framebuf[8];
    long zero_cross = 0, total = 0, prev_neg = 0;
    for (long i = 0; i < (long)(data_len / frame_bytes); i++) {
        if (fread(framebuf, 1, (size_t)frame_bytes, f) != (size_t)frame_bytes) break;
        int32_t val = 0;
        if (bytes_samp == 2) { int16_t v; memcpy(&v, framebuf, 2); val = v; }
        else { int32_t v; memcpy(&v, framebuf, 4); val = v >> 16; }
        if (val != 0) {
            int neg = val < 0;
            if (total > 0 && neg != prev_neg) zero_cross++;
            prev_neg = neg;
        }
        total++;
    }
    fclose(f);
    if (total < 100) return -3;
    double obs = (double)zero_cross / (double)total;
    double exp = 2.0 * 440.0 / (double)rate_expect;
    if (obs < exp * 0.6 || obs > exp * 1.4) return -2;
    return 0;
}

/* 字节保真校验（A3 高清 / DoP 透传）：WAV 头 rate/ch/bits 精确匹配 + data 段与 payload 逐字节一致。
 * 返回 0=合法且逐字节等同；-1=文件/头非法；-2=data_len 或内容不匹配。 */
static int wav_byte_exact(const char *path, int rate_expect, int ch_expect, int bits_expect,
                          const uint8_t *payload, size_t plen)
{
    FILE *f = fopen(path, "rb");
    if (!f) return -1;
    unsigned char h[44];
    if (fread(h, 1, 44, f) != 44) { fclose(f); return -1; }
    if (memcmp(h, "RIFF", 4) || memcmp(h + 8, "WAVE", 4) || memcmp(h + 12, "fmt ", 4)) { fclose(f); return -1; }
    uint16_t ch, bits; uint32_t rate, data_len, byterate;
    memcpy(&ch, h + 22, 2); memcpy(&rate, h + 24, 4); memcpy(&byterate, h + 28, 4); memcpy(&bits, h + 34, 2);
    memcpy(&data_len, h + 40, 4);
    if (ch != (uint16_t)ch_expect || rate != (uint32_t)rate_expect || bits != (uint16_t)bits_expect) { fclose(f); return -1; }
    if (byterate != rate * ch * bits / 8) { fclose(f); return -1; }
    if (data_len != (uint32_t)plen) { fclose(f); return -2; }
    uint8_t *body = malloc(plen ? plen : 1);
    if (!body) { fclose(f); return -1; }
    size_t rd = fread(body, 1, plen, f);
    fclose(f);
    int ok = (rd == plen) && (memcmp(body, payload, plen) == 0);
    free(body);
    return ok ? 0 : -2;
}

/* 等 WAV 头出现（设备已 dev_open 写入 44B 头）：**STOP 前调用**——修复 OPEN→write→STOP 过快时
 * 播放线程尚未来得及 reconfigure（设备未打开，STOP 的 session_end 清 reconfig → 空 WAV）的竞态。
 * 返回 0=头已出现；-1=超时。 */
static int wait_wav_open(const char *path, int tmo_ms)
{
    for (int i = 0; i < tmo_ms / 50; i++) {
        struct stat st;
        if (stat(path, &st) < 0) { usleep(50000); continue; }
        if (st.st_size >= 44) return 0;
        usleep(50000);
    }
    return -1;
}

int main(void)
{
    unlink(TSOCK); unlink(TWAV);
    g_audiod_pid = start_audiod();
    if (g_audiod_pid < 0) { printf("cannot fork audiod\n"); return 1; }
    usleep(300000);
    printf("=== meow_audiod host test (FILE sink) ===\n");

    /* ---- T1：全链路 OPEN→WRITE→QUERY→PAUSE/RESUME→STOP ---- */
    printf("[T1 full chain]\n");
    struct cli a;
    check(cli_connect(&a) == 0, "connect A");
    m_audio_open_ack_t ack;
    check(do_open(&a, 44100, 2, AUDIO_FMT_S16, &ack) == 0 && ack.err == MEOW_OK && ack.stream_id > 0, "open A");
    printf("  grant=%u/%u/%s sid=%u\n", (unsigned)ack.grant_rate, (unsigned)ack.grant_ch, (ack.grant_fmt == AUDIO_FMT_S16 ? "S16" : "S32"), (unsigned)ack.stream_id);
    uint8_t pcm[4096];
    size_t wb = gen_sine(pcm, sizeof pcm, (int)(ack.grant_fmt ? ack.grant_fmt : AUDIO_FMT_S16), 100, 440, 44100);
    check(wb > 0 && do_write(&a, pcm, (uint32_t)wb) == 0, "write A");
    usleep(150000);
    char q[1024];
    check(do_query(&a, q, sizeof q) == 0 && strstr(q, "active=1"), "query active");
    printf("  query: %s\n", q);
    check(do_ctrl(&a, MSG_AUDIO_PAUSE, ack.stream_id) == 0, "pause A");
    usleep(50000);
    do_query(&a, q, sizeof q);
    check(strstr(q, "paused=1") != NULL, "query paused");
    check(do_ctrl(&a, MSG_AUDIO_RESUME, ack.stream_id) == 0, "resume A");
    usleep(50000);
    check(do_ctrl(&a, MSG_AUDIO_STOP, ack.stream_id) == 0, "stop A");
    usleep(100000);
    do_query(&a, q, sizeof q);
    check(strstr(q, "active=0") != NULL, "stop -> inactive");
    close(a.fd);

    /* ---- T2：两个客户端抢占（旧收 PREEMPTED，PCM 丢弃） ---- */
    printf("[T2 preemption]\n");
    struct cli a2, b2;
    check(cli_connect(&a2) == 0, "connect A2");
    m_audio_open_ack_t ackA2;
    check(do_open(&a2, 48000, 2, AUDIO_FMT_S16, &ackA2) == 0 && ackA2.err == MEOW_OK, "open A2");
    size_t wb2 = gen_sine(pcm, sizeof pcm, (int)(ackA2.grant_fmt ? ackA2.grant_fmt : AUDIO_FMT_S16), 100, 440, 48000);
    do_write(&a2, pcm, (uint32_t)wb2);
    check(cli_connect(&b2) == 0, "connect B2");
    m_audio_open_ack_t ackB2;
    check(do_open(&b2, 96000, 2, AUDIO_FMT_S16, &ackB2) == 0 && ackB2.err == MEOW_OK, "open B2 (preempt)");
    /* A2 应收到 PREEMPTED */
    uint8_t rbuf[128]; uint16_t rt;
    int npr = rf_tmo(a2.fd, 1000, &rt, rbuf, sizeof rbuf);
    check(npr >= (int)sizeof(m_audio_preempted_t) && rt == MSG_AUDIO_PREEMPTED, "A2 got PREEMPTED");
    if (npr >= (int)sizeof(m_audio_preempted_t)) {
        m_audio_preempted_t pm; memcpy(&pm, rbuf, sizeof pm);
        printf("  preempted by %s (stream %u)\n", pm.by_app, (unsigned)pm.stream_id);
    }
    /* A2 写被丢弃；B2 写生效 */
    do_write(&a2, pcm, (uint32_t)wb2);       /* 应丢弃（A2 已 draining） */
    usleep(100000);
    do_query(&a2, q, sizeof q);
    printf("  after preempt, A2 query: %s\n", q);
    do_write(&b2, pcm, (uint32_t)wb2);
    usleep(100000);
    do_query(&b2, q, sizeof q);
    check(strstr(q, "active=1") && strstr(q, "rate=96000"), "B2 active after preempt");
    do_ctrl(&b2, MSG_AUDIO_STOP, ackB2.stream_id);
    do_ctrl(&a2, MSG_AUDIO_STOP, ackA2.stream_id);
    close(a2.fd); close(b2.fd);

    /* ---- T3：EOF 回收（客户端直接断链） ---- */
    printf("[T3 EOF recycle]\n");
    struct cli c3;
    check(cli_connect(&c3) == 0, "connect C3");
    m_audio_open_ack_t ackC3;
    check(do_open(&c3, 44100, 2, AUDIO_FMT_S16, &ackC3) == 0, "open C3");
    /* 不 STOP，直接断链（close fd）→ audiod poll 读到 EOF → 回收 */
    do_write(&c3, pcm, (uint32_t)gen_sine(pcm, sizeof pcm, AUDIO_FMT_S16, 100, 440, 44100));
    close(c3.fd);
    usleep(200000);
    struct cli c3q; check(cli_connect(&c3q) == 0, "connect C3q");
    do_query(&c3q, q, sizeof q);
    printf("  after EOF: %s\n", q);
    check(strstr(q, "active=0") != NULL, "EOF recycle -> inactive");
    close(c3q.fd);

    /* ---- T5：长流回归（3 分钟等效 PCM 持续灌；FILE sink 全速排空 → 加速时钟等效）。
     * 回归目标：真机「长流卡死」——喂流期间 listener/IO 循环必须持续可服务，
     * 帧数零丢失、零 underrun、零丢弃，STOP 后排空落盘完整。 ---- */
    printf("[T5 long stream (3min equivalent)]\n");
    struct cli l5;
    check(cli_connect(&l5) == 0, "connect L5");
    m_audio_open_ack_t ackL5;
    check(do_open(&l5, 44100, 2, AUDIO_FMT_S16, &ackL5) == 0 && ackL5.err == MEOW_OK, "open L5");
    uint32_t fs5 = (uint32_t)ackL5.grant_ch * (ackL5.grant_fmt == AUDIO_FMT_S16 ? 2u : 4u);
    if (fs5 == 0) fs5 = 4;
    uint64_t total_frames = 44100ULL * 180;             /* 3 分钟等效流 */
    uint64_t total_bytes = total_frames * fs5;
    uint8_t chunk[4096];
    memset(chunk, 0x5A, sizeof chunk);                  /* 内容无关：测完整性/不卡死 */
    size_t per = (sizeof chunk / fs5) * fs5;
    uint64_t sent = 0;
    int werr = 0, probe_n = 0, probe_ok = 0;
    while (sent < total_bytes) {
        uint64_t w = total_bytes - sent;
        if (w > per) w = per;
        if (do_write(&l5, chunk, (uint32_t)w) != 0) { werr = 1; break; }
        sent += w;
        if (sent % (512 * per) == 0) {                  /* 每 2MB 探一次 listener 活性 */
            struct cli s5;
            s5.fd = -1;
            probe_n++;
            if (cli_connect(&s5) == 0) {
                char q5[1024];
                if (do_query(&s5, q5, sizeof q5) == 0 && strstr(q5, "active=1")) probe_ok++;
                close(s5.fd);
            }
        }
    }
    check(!werr && sent == total_bytes, "long feed completed (io never stalled)");
    printf("  fed %llu bytes (%llu frames), mid-feed status probes %d/%d alive\n",
           (unsigned long long)sent, (unsigned long long)(sent / fs5), probe_ok, probe_n);
    check(probe_n >= 10 && probe_ok == probe_n, "listener/io alive during long feed");
    do_ctrl(&l5, MSG_AUDIO_STOP, ackL5.stream_id);
    /* 排空证明改为「WAV 写满 + STATE 归零」双判据：流结束后 played 已由 session_clean 清零
     * （会话回收契约），不再作排空判据；WAV size==44+fed 才是「帧无丢失」的 ground truth。 */
    long wavsz5 = -1;
    char q5[1024];
    int clean5 = 0;
    for (int i = 0; i < 300; i++) {                     /* 最多 30s 等排空+回填 WAV 头 */
        usleep(100000);
        do_query(&l5, q5, sizeof q5);
        FILE *f = fopen(TWAV, "rb");
        if (f) { fseek(f, 0, SEEK_END); wavsz5 = ftell(f); fclose(f); }
        if (wavsz5 == (long)(44 + total_bytes) && strstr(q5, "active=0") && strstr(q5, "played=0")) {
            clean5 = 1; break;
        }
    }
    check(clean5, "long stream fully played (WAV==fed bytes, STATE clean)");
    check(strstr(q5, "underrun=0") != NULL && strstr(q5, "dropped=0") != NULL,
          "no underrun/drop on long stream");
    check(wavsz5 == (long)(44 + total_bytes), "long WAV size == 44 + fed bytes");
    close(l5.fd);

    /* ---- T4：tone 写 WAV（由 CLI 走完整 IPC 链路；mipsel/host CLI 共用） ---- */
    printf("[T4 tone -> WAV]\n");
    unlink(TWAV);
    pid_t tone_pid = fork();
    if (tone_pid == 0) {
        setenv("MEOW_AUDIO_SOCK", TSOCK, 1);
        execl("./meow_audio_host", "meow_audio_host", "tone", "440", "500", "44100", (char *)0);
        _exit(127);
    }
    waitpid(tone_pid, NULL, 0);
    usleep(300000);
    check(verify_wav(TWAV, 44100, 2, 16) == 0, "WAV valid sine");
    printf("  wav size: ");
    { FILE *f = fopen(TWAV, "rb"); if (f) { fseek(f, 0, SEEK_END); printf("%ld bytes\n", ftell(f)); fclose(f); } }

    stop_audiod();

    /* ---- T6：设备 wedge 生存（故障注入复现真机长流卡死场景）。
     * MEOW_AUDIO_TEST_WEDGE_AFTER_BYTES=128KB → 播放线程永久堵在 dev_write（睡到 g_stop）。
     * 旧代码：ring 满 → IO 线程 ring_write cond_wait 永不醒 → accept 停摆 → 全链冻结。
     * 护栏后：ring 写有界（RING_WAIT_MS=50ms）超时丢弃，IO/accept/preempt 全部存活。 ---- */
    printf("[T6 device wedge survival]\n");
    unlink(TSOCK);
    g_audiod_pid = start_audiod_ex("null", "131072", "50");
    usleep(400000);
    struct cli w6;
    check(cli_connect(&w6) == 0, "connect W6");
    m_audio_open_ack_t ackW6;
    check(do_open(&w6, 44100, 2, AUDIO_FMT_S16, &ackW6) == 0 && ackW6.err == MEOW_OK, "open W6");
    int werr6 = 0;
    uint64_t sent6 = 0;
    for (int i = 0; i < 100; i++) {                     /* 400KB：128KB 后 wedge，其余全靠丢弃 */
        if (do_write(&w6, chunk, (uint32_t)per) != 0) { werr6 = 1; break; }
        sent6 += per;
    }
    check(!werr6 && sent6 == 100 * (uint64_t)per, "feed continues across wedge (no deadlock)");
    struct cli s6;
    s6.fd = -1;
    char q6[1024];
    int io_alive = 0;
    if (cli_connect(&s6) == 0) {
        if (do_query(&s6, q6, sizeof q6) == 0 && strstr(q6, "route_mode=")) io_alive = 1;
        close(s6.fd);
    }
    check(io_alive, "io loop alive after wedge (connect+query served)");
    check(io_alive && strstr(q6, "dropped=") != NULL && atoi(strstr(q6, "dropped=") + 8) > 0,
          "drop policy engaged (dropped>0)");
    struct cli p6;
    p6.fd = -1;
    int pre6 = 0;
    if (cli_connect(&p6) == 0) {
        m_audio_open_ack_t ak6;
        if (do_open(&p6, 48000, 2, AUDIO_FMT_S16, &ak6) == 0 && ak6.err == MEOW_OK) pre6 = 1;
        close(p6.fd);
    }
    check(pre6, "preempt OPEN granted while wedged");
    close(w6.fd);
    check(stop_audiod_tmo(5000) != 0, "wedged audiod exits on SIGTERM within 5s");

    /* ---- T7：慢/不读客户端下行丢弃（server→client 写绝不堵 IO 循环）。
     * Z 狂发 QUERY 从不读响应 → server 下行缓冲灌满 → send_frame 单发即丢（txdrop++）。
     * 护栏断言：server 不卡死、新连接照常服务、txdrop 有计数。 ---- */
    printf("[T7 slow-client tx drop]\n");
    unlink(TSOCK);
    g_audiod_pid = start_audiod_ex("null", NULL, NULL);
    usleep(400000);
    struct cli z7;
    check(cli_connect(&z7) == 0, "connect Z7");
    int serr7 = 0, sent7 = 0;
    for (int i = 0; i < 2000; i++) {
        if (sf(z7.fd, MSG_AUDIO_QUERY, 9, NULL, 0) != 0) { serr7 = 1; break; }
        sent7++;
    }
    check(!serr7 && sent7 == 2000, "query spam sent (client never reads)");
    struct cli f7;
    f7.fd = -1;
    char q7[1024];
    int alive7 = 0;
    if (cli_connect(&f7) == 0) {
        if (do_query(&f7, q7, sizeof q7) == 0 && strstr(q7, "route_mode=")) alive7 = 1;
        close(f7.fd);
    }
    check(alive7, "server responsive after tx drops");
    check(alive7 && strstr(q7, "txdrop=") != NULL && atoi(strstr(q7, "txdrop=") + 7) > 0,
          "txdrop counted");
    close(z7.fd);
    stop_audiod();

    /* ---- T8：数字域电平表 + 全面监控日志（M2.97 DAC 实时监控）。
     * 已知幅度正弦（amp=0.3, 440Hz）：理论 RMS=0.3/√2 → -13.5dBFS，peak=0.3 → -10.5dBFS。
     * audiod 电平表为整数近似（octave 线性插值，误差 ~0.5dB）→ 容差 ±2.5dB。
     * 监控日志：流活跃期主线程 1s 节拍写 /tmp/audio_monitor_<bootts>.log（宿主无卡降级）。 ---- */
    printf("[T8 level meter + monitor log]\n");
    unlink(TSOCK); unlink(TWAV);
    g_audiod_pid = start_audiod();           /* file sink */
    usleep(400000);
    struct cli m8;
    check(cli_connect(&m8) == 0, "connect M8");
    m_audio_open_ack_t ackM8;
    check(do_open(&m8, 44100, 2, AUDIO_FMT_S16, &ackM8) == 0 && ackM8.err == MEOW_OK, "open M8");
    /* 喂 ~270ms 的 440Hz/0.3 幅度正弦（>2 个 100ms 窗口） */
    for (int i = 0; i < 12; i++)
        do_write(&m8, pcm, (uint32_t)gen_sine(pcm, sizeof pcm, AUDIO_FMT_S16, 1000, 440, 44100));
    char q8[1024];
    check(do_query(&m8, q8, sizeof q8) == 0 && strstr(q8, "rms=") && strstr(q8, "peak="),
          "query exposes rms/peak keys");
    int rms8 = -990, pk8 = -990;
    for (int i = 0; i < 20; i++) {              /* 最多 2s 等首个窗口结算（播放排空竞态护栏） */
        do_query(&m8, q8, sizeof q8);
        rms8 = atoi(strstr(q8, "rms=") + 4);
        pk8  = atoi(strstr(q8, "peak=") + 5);
        if (rms8 > -990) break;
        usleep(100000);
    }
    printf("  sine 0.3: rms=%d peak=%d (expect rms≈-135 peak≈-105 deci-dB)\n", rms8, pk8);
    check(rms8 >= -160 && rms8 <= -110, "sine RMS ≈ -13.5dBFS (±2.5dB)");
    check(pk8 >= -130 && pk8 <= -80, "sine peak ≈ -10.5dBFS (±2.5dB)");
    /* 静音 → 地板（轮询等窗口结算：窗口按块粒度对齐，消除播放排空时序竞态） */
    {
        uint8_t zeros[4096];
        memset(zeros, 0, sizeof zeros);
        for (int i = 0; i < 8; i++) do_write(&m8, zeros, sizeof zeros);   /* ~186ms */
        int floor_ok = 0;
        for (int i = 0; i < 20; i++) {              /* 最多 2s 等纯零窗口结算 */
            usleep(100000);
            do_query(&m8, q8, sizeof q8);
            rms8 = atoi(strstr(q8, "rms=") + 4);
            pk8 = atoi(strstr(q8, "peak=") + 5);
            if (rms8 <= -990 && pk8 <= -990) { floor_ok = 1; break; }
        }
        printf("  silence: rms=%d peak=%d\n", rms8, pk8);
        check(floor_ok, "silence -> -inf floor");
    }
    /* monitor CLI 冒烟（流仍活跃：输出含电平字段+电平条） */
    {
        unlink("/tmp/meow_mon_cli.out");
        pid_t mp = fork();
        if (mp == 0) {
            setenv("MEOW_AUDIO_SOCK", TSOCK, 1);
            int fd = open("/tmp/meow_mon_cli.out", O_WRONLY | O_CREAT | O_TRUNC, 0644);
            if (fd >= 0) { dup2(fd, 1); close(fd); }
            execl("./meow_audio_host", "meow_audio_host", "monitor", "2", (char *)0);
            _exit(127);
        }
        int mst = 0;
        waitpid(mp, &mst, 0);
        char mb[4096];
        int ml = 0;
        int fd = open("/tmp/meow_mon_cli.out", O_RDONLY);
        if (fd >= 0) { ml = (int)read(fd, mb, sizeof mb - 1); close(fd); if (ml > 0) mb[ml] = 0; }
        check(ml > 0 && strstr(mb, "rms=") && strstr(mb, "LIVE") && strchr(mb, '['),
              "monitor CLI prints live level bar");
    }
    /* 监控日志文件：活跃期应已写入（前面耗时已超 2 个 1s 节拍） */
    char bootts[64] = "";
    {
        int fd = open("/tmp/meow_bootts", O_RDONLY);
        if (fd >= 0) { ssize_t r = read(fd, bootts, 63); close(fd); if (r > 0) bootts[r] = 0; }
    }
    char monpath[160];
    snprintf(monpath, sizeof monpath, "/tmp/audio_monitor_%s.log", bootts);
    char monbuf[4096];
    int monlen = 0;
    {
        int fd = open(monpath, O_RDONLY);
        if (fd >= 0) { monlen = (int)read(fd, monbuf, sizeof monbuf - 1); close(fd); if (monlen > 0) monbuf[monlen] = 0; }
    }
    check(monlen > 0 && strstr(monbuf, "app=test") && strstr(monbuf, "rms=") &&
          strstr(monbuf, "hwrate=") && strstr(monbuf, "vol="),
          "monitor log file written while stream active");
    /* 流停止即停写 */
    do_ctrl(&m8, MSG_AUDIO_STOP, ackM8.stream_id);
    usleep(1400000);
    off_t msz1 = -1, msz2 = -1;
    { int fd = open(monpath, O_RDONLY); if (fd >= 0) { msz1 = lseek(fd, 0, SEEK_END); close(fd); } }
    usleep(1400000);
    { int fd = open(monpath, O_RDONLY); if (fd >= 0) { msz2 = lseek(fd, 0, SEEK_END); close(fd); } }
    check(msz1 >= 0 && msz1 == msz2, "monitor log stops when stream stops");
    close(m8.fd);
    stop_audiod();

    /* ---- T9：孤儿会话回收（客户端崩溃/被杀 → 会话完整回收 → STATE 归零）。
     * 复现 ncm 被内核 OOM 杀（sig=9）场景：客户端子进程 OPEN + 写正弦（使 written/played/rms/peak/
     * lvlseq 非零、流活跃），随即 SIGKILL 子进程（内核自动关 socket fd）——audiod 应检测 EOF 并完整
     * 回收：active=0/sid=0/written=0/played=0/underrun=0/rms=peak=-inf/lvlseq=0，STATE 回干净无流基线。 ---- */
    printf("[T9 orphan reclaim (client SIGKILL)]\n");
    unlink(TSOCK); unlink(TWAV);
    g_audiod_pid = start_audiod();           /* file sink */
    usleep(400000);
    {
        int p9[2];
        if (pipe(p9) == 0) {
            pid_t kid = fork();
            if (kid == 0) {
                /* 子进程 = 客户端：OPEN + 写足够正弦（≥2 窗口，使电平表结算）→ 通知父进程后挂死 */
                close(p9[0]);
                setenv("MEOW_AUDIO_SOCK", TSOCK, 1);
                struct cli c9;
                if (cli_connect(&c9) != 0) _exit(2);
                m_audio_open_ack_t ack9;
                if (do_open(&c9, 44100, 2, AUDIO_FMT_S16, &ack9) != 0 || ack9.err != MEOW_OK) _exit(3);
                uint8_t pc9[4096];
                for (int i = 0; i < 12; i++) {
                    size_t w9 = gen_sine(pc9, sizeof pc9, AUDIO_FMT_S16, 1000, 440, 44100);
                    if (do_write(&c9, pc9, (uint32_t)w9) != 0) _exit(4);
                }
                char ok = 1;
                if (write(p9[1], &ok, 1) != 1) _exit(5);
                for (;;) pause();            /* 等父进程 SIGKILL（模拟 OOM sig=9） */
            }
            close(p9[1]);
            char ok = 0;
            int got = (int)read(p9[0], &ok, 1);      /* 等子进程写完 */
            close(p9[0]);
            check(got == 1 && ok == 1, "child client wrote audio (stream active)");
            /* pre-death：流活跃 + 电平表已污染（证明待回收的会话有非零统计） */
            int pre9 = 0;
            char q9b[1024] = "";
            for (int i = 0; i < 20; i++) {           /* 最多 2s 等电平窗口结算 */
                struct cli q9c;
                if (cli_connect(&q9c) != 0) { usleep(100000); continue; }
                if (do_query(&q9c, q9b, sizeof q9b) == 0) {
                    int rms9 = atoi(strstr(q9b, "rms=") + 4);
                    int lvl9 = atoi(strstr(q9b, "lvlseq=") + 7);
                    if (strstr(q9b, "active=1") && rms9 > -990 && lvl9 > 0) { pre9 = 1; close(q9c.fd); break; }
                }
                close(q9c.fd);
                usleep(100000);
            }
            printf("  pre-crash: %s", q9b);
            check(pre9, "stream active & meter populated before crash");
            /* 模拟崩溃：SIGKILL 子进程（内核关 socket fd → audiod poll 到 EOF → 回收） */
            kill(kid, SIGKILL);
            waitpid(kid, NULL, 0);
            /* post-death：轮询直到 STATE 完全归零（排空后 session_clean） */
            int clean9 = 0;
            char q9a[1024] = "";
            for (int i = 0; i < 40; i++) {           /* 最多 4s */
                usleep(100000);
                struct cli q9c;
                if (cli_connect(&q9c) != 0) continue;
                if (do_query(&q9c, q9a, sizeof q9a) == 0) {
                    int rr = atoi(strstr(q9a, "rms=") + 4);
                    int pp = atoi(strstr(q9a, "peak=") + 5);
                    int lv = atoi(strstr(q9a, "lvlseq=") + 7);
                    if (strstr(q9a, "active=0") && strstr(q9a, "sid=0") &&
                        strstr(q9a, "written=0") && strstr(q9a, "played=0") &&
                        strstr(q9a, "underrun=0") && rr <= -990 && pp <= -990 && lv == 0) {
                        clean9 = 1; close(q9c.fd); break;
                    }
                }
                close(q9c.fd);
            }
            printf("  post-crash: %s", q9a);
            check(clean9, "SIGKILL orphan -> STATE fully clean (sid/written/played/rms/peak/lvlseq zeroed)");
            check(strstr(q9a, "active=0") != NULL && strstr(q9a, "app=-") != NULL,
                  "orphan query shows no-stream baseline");
        } else {
            check(0, "pipe for T9 child");
        }
    }
    /* ---- T10：连接表溢出丢弃护栏与回收（回归 fd=N accept 风暴，§2026-09-02 真机 1489 次）。
     * 背景：CLI_MAX=8（§12「客户端全有界」护栏）。ncm「每次 audio_out_open 新建一条短连接」
     * （旧 audio_out_sync_volume）在边下边播/切歌 churn 下会反复占用连接槽：8 张表占满后，
     * 新 connect 的 accept 因 cli_alloc 失败被**安全丢弃**（日志 "client limit reached, drop"），
     * 表回收后 NEW 连接照常服务。本用例：
     *   ① 洪泛 connect→write→close ×60（远超 CLI_MAX=8，走上述 drop 护栏）；
     *   ② 断言 audiod **不 wedge/不崩**（此后 SIGTERM 干净退出）；
     *   ③ 等表回收（短连接已 close，EOF 逐 poll 回收）后，新 OPEN 仍被授权（fd 复用回收）。
     * 「同一 fd=N 被反复 accept」= 对端短连接 + fd 低位复用，本是**正常回收机理**，非循环缺陷；
     * 根因在对端每 open 建新连接，由 ncm side audio_out.c「音量同步每进程一次」消除（vol_sync_sim）。 ---- */
    printf("[T10 client-table overflow guard & recycle]\n");
    unlink(TSOCK);
    g_audiod_pid = start_audiod_ex("null", NULL, NULL);
    usleep(400000);
    int burst = 0;
    for (int i = 0; i < 60; i++) {                 /* 洪泛 > CLI_MAX=8 */
        struct cli v;
        if (cli_connect(&v) == 0) {
            int32_t pct = 50;
            if (sf(v.fd, MSG_AUDIO_VOLUME, 7, &pct, sizeof pct) == 0) burst++;
            close(v.fd);            /* 对端读 EOF → cli_free 回收 */
        }
    }
    printf("  issued=%d/60 (cap by CLI_MAX=8 overflow drops)\n", burst);
    check(burst > 0, "connections issued (overflow hits drop guard)");
    /* ③ 等表回收（≤1s：EOF 逐 poll 回收）后新 OPEN 仍被授权 */
    usleep(700000);
    int eok = 0;
    {
        struct cli e;
        if (cli_connect(&e) == 0) {
            m_audio_open_ack_t ak;
            if (do_open(&e, 48000, 2, AUDIO_FMT_S16, &ak) == 0 && ak.err == MEOW_OK) eok = 1;
            close(e.fd);
        }
    }
    check(eok, "fresh OPEN after overflow (table recycled, no exhaustion/wedge)");
    check(stop_audiod_tmo(5000) != 0, "audiod not wedged by overflow (SIGTERM clean exit)");

    /* ---- T11：P2 蓝牙 输出目标（OUT_BT）+ 音量 AVRCP 隔离 + 格式归一 + codec。
     * 宿主以 FILE sink 跑（真 bluealsa 传输留给真机），验证目标选择/音量隔离/格式逻辑：
     *   - settings.conf `audio.output_bt=1` + `bt.codec=SBC` → target=bt / codec=SBC / volctl=avrcp / grant fmt=S16；
     *   - BT 下 MSG_AUDIO_VOLUME 设置：**不下发 DAC 音量反转**——g_vol_pct 不变、不持久化 audio.volume、
     *     volctl 仍 avrcp（隔离成立）；
     *   - MSG_AUDIO_OUTPUT 切回 DAC：target=dac / volctl=dac；此后音量设置写 DAC + 持久化 audio.volume。
     * 断言：BT 路径绝不动 DAC 音量（plan §三/§五「两套隔离」）；BT 格式归一=S16；codec 读到生效。 ---- */
    printf("[T11 BT output target + AVRCP vol isolation]\n");
    unlink(TSOCK); unlink(TWAV);
    const char *tconf = "/tmp/meow_test_settings.conf";
    FILE *tf = fopen(tconf, "w");
    if (tf) { fprintf(tf, "# meow-settings 1\naudio.volume = 60\naudio.output_bt = 1\nbt.codec = SBC\n"); fclose(tf); }
    g_audiod_pid = start_audiod_settings("file", tconf);
    usleep(400000);
    struct cli b11;
    check(cli_connect(&b11) == 0, "connect B11");
    m_audio_open_ack_t ack11;
    check(do_open(&b11, 44100, 2, AUDIO_FMT_S16, &ack11) == 0 && ack11.err == MEOW_OK, "open B11 (bt)");
    char q11[1024];
    check(do_query(&b11, q11, sizeof q11) == 0 && strstr(q11, "target=bt"),
          "settings output_bt=1 -> target=bt");
    check(strstr(q11, "codec=SBC") != NULL, "settings bt.codec=SBC -> codec=SBC");
    check(strstr(q11, "volctl=avrcp") != NULL, "bt -> volctl=avrcp (AVRCP vol control)");
    check(strstr(q11, "fmt=S16") != NULL, "bt grant fmt=S16 (format normalize)");
    /* BT/file sink 写一段流（应正常落盘到 WAV） */
    do_write(&b11, pcm, (uint32_t)gen_sine(pcm, sizeof pcm, (int)(ack11.grant_fmt ? ack11.grant_fmt : AUDIO_FMT_S16), 600, 440, 44100));
    usleep(150000);
    /* 音量设置 while BT：不下发 DAC——g_vol_pct 不变（60）、不持久化 audio.volume=40、volctl 仍 avrcp */
    {
        int32_t pct = 40;
        if (sf(b11.fd, MSG_AUDIO_VOLUME, 8, &pct, sizeof pct) == 0) {
            uint8_t ab[64]; uint16_t at; rf(b11.fd, &at, ab, sizeof ab);   /* 消费 ACK */
        }
        usleep(100000);
    }
    check(do_query(&b11, q11, sizeof q11) == 0 && strstr(q11, "volctl=avrcp"),
          "vol set while bt -> volctl still avrcp (isolation)");
    check(strstr(q11, "vol=60") != NULL, "vol set while bt -> DAC vol unchanged (60)");
    {
        FILE *chk = fopen(tconf, "r"); int has40 = 0; char l[128];
        if (chk) { while (fgets(l, sizeof l, chk)) if (strstr(l, "audio.volume = 40")) has40 = 1; fclose(chk); }
        check(!has40, "bt vol set does NOT persist audio.volume=40");
    }
    /* MSG_AUDIO_OUTPUT 切回 DAC */
    {
        m_audio_output_t oo; oo.target = AUDIO_OUT_DAC;
        if (sf(b11.fd, MSG_AUDIO_OUTPUT, 9, &oo, sizeof oo) == 0) {
            uint8_t ab[64]; uint16_t at; rf(b11.fd, &at, ab, sizeof ab);
        }
        usleep(150000);
    }
    check(do_query(&b11, q11, sizeof q11) == 0 && strstr(q11, "target=dac"),
          "MSG_AUDIO_OUTPUT -> target=dac");
    check(strstr(q11, "volctl=dac") != NULL, "dac -> volctl=dac");
    /* 现在音量设置应写 DAC + 持久化 */
    {
        int32_t pct = 40;
        if (sf(b11.fd, MSG_AUDIO_VOLUME, 10, &pct, sizeof pct) == 0) {
            uint8_t ab[64]; uint16_t at; rf(b11.fd, &at, ab, sizeof ab);
        }
        usleep(150000);
    }
    check(do_query(&b11, q11, sizeof q11) == 0 && strstr(q11, "vol=40"), "dac vol set -> g_vol_pct=40");
    {
        FILE *chk = fopen(tconf, "r"); int has40 = 0; char l[128];
        if (chk) { while (fgets(l, sizeof l, chk)) if (strstr(l, "audio.volume = 40")) has40 = 1; fclose(chk); }
        check(has40, "dac vol set persists audio.volume=40");
    }
    do_ctrl(&b11, MSG_AUDIO_STOP, ack11.stream_id);
    close(b11.fd);
    stop_audiod();

    /* ---- T12：24/32bit 高清流 byte-exact（A3 高清实测；FILE sink 按请求保真，S32 升位不降位）。
     * ① S32@192000：open 应 grant S32（FILE/NULL sink 按 native 高保真透传）；写已知 32-bit 交织帧，
     *    验证 WAV 为 32-bit 且 data 段与 payload 逐字节相等（无降位/无重排）。
     * ② S24@88200（32-in-32）：grant S24，WAV 32-bit 逐字节等同。鉴真机 DAC 高清率由 hw_probe 决定。 */
    printf("[T12 24/32bit hi-res byte-exact]\n");
    unlink(TSOCK); unlink(TWAV);
    g_audiod_pid = start_audiod();           /* file sink */
    usleep(400000);
    {
        struct cli h12;
        check(cli_connect(&h12) == 0, "connect H12");
        m_audio_open_ack_t ack12;
        check(do_open_f(&h12, 192000, 2, AUDIO_FMT_S32, 0, &ack12) == 0 && ack12.err == MEOW_OK,
              "open S32@192000");
        check(ack12.grant_fmt == AUDIO_FMT_S32, "grant S32 for S32 request (FILE byte-exact)");
        check(ack12.grant_rate == 192000, "grant_rate=192000 (no SRC)");
        uint8_t pl[4096];
        size_t fs12 = 2 * 4;                 /* stereo S32 */
        size_t nframes = sizeof pl / fs12;
        uint8_t *op = pl;
        for (size_t i = 0; i < nframes; i++) {
            uint32_t l = (uint32_t)(((i * 7u) & 0xFFFFu) << 16);
            uint32_t r = (uint32_t)((0x10000u - ((i * 7u) & 0xFFFFu)) << 16);
            memcpy(op, &l, 4); op += 4; memcpy(op, &r, 4); op += 4;
        }
        do_write(&h12, pl, (uint32_t)sizeof pl);
        char q12[1024];
        do_query(&h12, q12, sizeof q12);                 /* 活动态快照 + 给播放线程时间重配设备 */
        check(strstr(q12, "fmt=S32") != NULL, "query fmt=S32 (hi-res format exposed)");
        wait_wav_open(TWAV, 3000);                       /* 等设备开（WAV 头已在），再 STOP */
        do_ctrl(&h12, MSG_AUDIO_STOP, ack12.stream_id);
        for (int i = 0; i < 300; i++) {      /* ≤30s 等排空 + WAV 头回填 */
            usleep(100000);
            if (wav_byte_exact(TWAV, 192000, 2, 32, pl, sizeof pl) == 0) break;
        }
        check(wav_byte_exact(TWAV, 192000, 2, 32, pl, sizeof pl) == 0,
              "S32@192000 WAV byte-exact (32-bit, no downshift)");
        /* ② S24@88200（32-in-32） */
        unlink(TWAV);
        struct cli h12b;
        check(cli_connect(&h12b) == 0, "connect H12b");
        m_audio_open_ack_t ack12b;
        check(do_open_f(&h12b, 88200, 2, AUDIO_FMT_S24, 0, &ack12b) == 0 && ack12b.err == MEOW_OK,
              "open S24@88200");
        check(ack12b.grant_fmt == AUDIO_FMT_S24, "grant S24 for S24 request (32-in-32)");
        uint8_t pl2[4096];
        size_t fs24 = 2 * 4;
        size_t n2 = sizeof pl2 / fs24;
        uint8_t *op2 = pl2;
        for (size_t i = 0; i < n2; i++) {
            uint32_t l = (uint32_t)((i * 11u) << 8);   /* 24-bit 区在 [31:8] */
            uint32_t r = (uint32_t)(0x1000000u - ((i * 11u) << 8));
            memcpy(op2, &l, 4); op2 += 4; memcpy(op2, &r, 4); op2 += 4;
        }
        do_write(&h12b, pl2, (uint32_t)sizeof pl2);
        char q12b[1024];
        do_query(&h12b, q12b, sizeof q12b);                 /* 活动态快照：fmt 未清 */
        check(strstr(q12b, "fmt=S24") != NULL, "query fmt=S24 (hi-res format exposed)");
        wait_wav_open(TWAV, 3000);                          /* 等设备开（WAV 头已在），再 STOP */
        do_ctrl(&h12b, MSG_AUDIO_STOP, ack12b.stream_id);
        for (int i = 0; i < 300; i++) {
            usleep(100000);
            if (wav_byte_exact(TWAV, 88200, 2, 32, pl2, sizeof pl2) == 0) break;
        }
        check(wav_byte_exact(TWAV, 88200, 2, 32, pl2, sizeof pl2) == 0,
              "S24@88200 WAV byte-exact (32-in-32)");
        close(h12.fd); close(h12b.fd);
    }
    stop_audiod();

    /* ---- T13：DoP DSD 透传（A3+DSD：fmt=DOP+flags=DSD，audiod 只透传；不做 dsd2pcm）。
     * 写已知 DoP 帧（32-bit：bits[31:16]=16bit DSD，bits[15:8]=标记 0xFA(L)/0x05(R)），
     * 验证 grant=DOP、WAV 32-bit 逐字节等同（透传保真）、query fmt=DoP dsd=1。 */
    printf("[T13 DoP DSD passthrough]\n");
    unlink(TSOCK); unlink(TWAV);
    g_audiod_pid = start_audiod();
    usleep(400000);
    {
        struct cli d13;
        check(cli_connect(&d13) == 0, "connect D13");
        m_audio_open_ack_t ack13;
        check(do_open_f(&d13, 176400, 2, AUDIO_FMT_DOP, AUDIO_FLAG_DSD, &ack13) == 0 && ack13.err == MEOW_OK,
              "open DoP@176400 (DSD64)");
        check(ack13.grant_fmt == AUDIO_FMT_DOP, "grant=DoP (DOP passthrough)");
        check(ack13.grant_rate == 176400, "grant_rate=176400 (container rate, no SRC)");
        /* DoP 帧：16bit DSD 数据（左/右不同）+ 标记字节 */
        uint8_t dop[4096];
        size_t fsd = 2 * 4;
        size_t nd = sizeof dop / fsd;
        uint8_t *od = dop;
        for (size_t i = 0; i < nd; i++) {
            uint32_t wl = ((uint32_t)(i & 0xFFFFu) << 16) | (0xFAu << 8);   /* 标记 0xFA=左 */
            uint32_t wr = ((uint32_t)(~i & 0xFFFFu) << 16) | (0x05u << 8);  /* 标记 0x05=右 */
            memcpy(od, &wl, 4); od += 4; memcpy(od, &wr, 4); od += 4;
        }
        do_write(&d13, dop, (uint32_t)sizeof dop);
        char q13[1024];
        do_query(&d13, q13, sizeof q13);                    /* 活动态快照：fmt=DoP/dsd=1 */
        check(strstr(q13, "fmt=DoP") != NULL, "query fmt=DoP");
        check(strstr(q13, "dsd=1") != NULL, "query dsd=1 (DoP stream active)");
        wait_wav_open(TWAV, 3000);                          /* 等设备开（WAV 头已在），再 STOP */
        do_ctrl(&d13, MSG_AUDIO_STOP, ack13.stream_id);
        for (int i = 0; i < 300; i++) {
            usleep(100000);
            if (wav_byte_exact(TWAV, 176400, 2, 32, dop, sizeof dop) == 0) break;
        }
        check(wav_byte_exact(TWAV, 176400, 2, 32, dop, sizeof dop) == 0,
              "DoP WAV byte-exact (32-bit container, marker preserved)");
        /* 无 DSD 标志的 DOP 请求 → 拒（INVAL）：DoP 必须带 AUDIO_FLAG_DSD */
        struct cli d13b;
        check(cli_connect(&d13b) == 0, "connect D13b");
        m_audio_open_ack_t ack13b;
        check(do_open_f(&d13b, 176400, 2, AUDIO_FMT_DOP, 0, &ack13b) == 0 && ack13b.err == MEOW_ERR_INVAL,
              "DoP without AUDIO_FLAG_DSD rejected (INVAL)");
        close(d13.fd); close(d13b.fd);
    }
    stop_audiod();

    /* ---- T14：DSD 失败回退 = 报错关流（案 A；不引 dsd2pcm、不静默退化）。
     * output_bt=1（BT 目标）下 DoP open → MEOW_ERR_NODEV（BT/A2DP 不能承载 DoP）；
     * 此后普通 PCM（S16）open 仍正常（BT 目标不变），证明失败只关该 DSD 流、不殃及目标。 */
    printf("[T14 DSD fallback (BT) = error/close]\n");
    unlink(TSOCK); unlink(TWAV);
    const char *tconf14 = "/tmp/meow_test_settings14.conf";
    FILE *tf14 = fopen(tconf14, "w");
    if (tf14) { fprintf(tf14, "# meow-settings 1\naudio.volume = 60\naudio.output_bt = 1\n"); fclose(tf14); }
    g_audiod_pid = start_audiod_settings("file", tconf14);
    usleep(400000);
    {
        struct cli d14;
        check(cli_connect(&d14) == 0, "connect D14");
        m_audio_open_ack_t ack14;
        check(do_open_f(&d14, 176400, 2, AUDIO_FMT_DOP, AUDIO_FLAG_DSD, &ack14) == 0 &&
              ack14.err == MEOW_ERR_NODEV, "DoP on BT target rejected (NODEV)");
        /* 失败后 state 归干净（无流基线）；同目标普通 PCM 正常开 */
        struct cli d14b;
        check(cli_connect(&d14b) == 0, "connect D14b");
        m_audio_open_ack_t ack14b;
        check(do_open(&d14b, 44100, 2, AUDIO_FMT_S16, &ack14b) == 0 && ack14b.err == MEOW_OK,
              "PCM open still ok on BT after DSD reject");
        do_ctrl(&d14b, MSG_AUDIO_STOP, ack14b.stream_id);
        close(d14.fd); close(d14b.fd);
    }
    stop_audiod();

    /* ---- T15：音量收编 v2 双组写 + 权威（A3：audiod 唯一音量权威；泛化双组写 PCM+DSD_VOLUME；
     * 维持平方锥度；audio.volume 由 audiod 读写权威）。amixer 轨迹断言：一次 vol set 同发 numid=1/2(DSD)。
     * 全部经 MSG_AUDIO_VOLUME —— 权威路径；host FILE sink 无真实 amixer（popen 失败仍记 trace）。 */
    printf("[T15 volume v2 dual-group write + authority]\n");
    unlink(TSOCK); unlink(TWAV);
    const char *tconf15 = "/tmp/meow_test_settings15.conf";
    FILE *tf15 = fopen(tconf15, "w");
    if (tf15) { fprintf(tf15, "# meow-settings 1\naudio.volume = 60\n"); fclose(tf15); }
    const char *trace15 = "/tmp/meow_amixer_trace15.txt";
    unlink(trace15);
    g_audiod_pid = start_audiod_trace("file", tconf15, trace15);
    usleep(400000);
    {
        struct cli v15;
        check(cli_connect(&v15) == 0, "connect V15");
        m_audio_open_ack_t ack15;
        check(do_open(&v15, 44100, 2, AUDIO_FMT_S16, &ack15) == 0 && ack15.err == MEOW_OK, "open V15");
        /* 权威写音量（非 BT→DAC）：设置 40 */
        {
            int32_t pct = 40;
            if (sf(v15.fd, MSG_AUDIO_VOLUME, 15, &pct, sizeof pct) == 0) {
                uint8_t ab[64]; uint16_t at; rf(v15.fd, &at, ab, sizeof ab);
            }
        }
        usleep(150000);
        char q15[1024];
        check(do_query(&v15, q15, sizeof q15) == 0 && strstr(q15, "vol=40"),
              "authority vol set -> g_vol_pct=40 (audiod authoritative)");
        /* 持久化 audio.volume（audiod 读写权威，与 launcher/watchdog 同源同键） */
        {
            FILE *chk = fopen(tconf15, "r"); int has40 = 0; char l[128];
            if (chk) { while (fgets(l, sizeof l, chk)) if (strstr(l, "audio.volume = 40")) has40 = 1; fclose(chk); }
            check(has40, "audio.volume persisted = 40 (audiod authority)");
        }
        /* 双组写断言：trace 含 numid=1、numid=2、且 DSD_VOLUME(11) 同值（40→锥度≈40×40×192/10000≈30） */
        {
            char trb[4096]; int trl = 0;
            int fd = open(trace15, O_RDONLY);
            if (fd >= 0) { trl = (int)read(fd, trb, sizeof trb - 1); close(fd); if (trl > 0) trb[trl] = 0; }
            check(trl > 0 && strstr(trb, "cset numid=1 ") && strstr(trb, "cset numid=2 ") &&
                  strstr(trb, "cset numid=11 "), "dual-group write: PCM numid=1/2 + DSD_VOLUME numid=11");
            /* 平方锥度：pct=40 → dac = (100-40)^2*192/10000 = 69.12 → 69（±1 容差） */
            int dac40 = (100 - 40) * (100 - 40) * 192 / 10000;
            /* 从 trace 找 numid=2 的值，应与 dac40 一致 */
            const char *p2 = strstr(trb, "cset numid=2 ");
            int got2 = p2 ? atoi(p2 + strlen("cset numid=2 ")) : -1;
            check(got2 == dac40, "square taper kept (numid=2 == (100-40)^2*192/10000)");
        }
        do_ctrl(&v15, MSG_AUDIO_STOP, ack15.stream_id);
        close(v15.fd);
    }
    stop_audiod();

    /* ---- T16：监控日志记录高清/DoP 实际率 + 格式（A3：monitor 记录实际率；DSD 标记）。
     * 生命周期同 T8：流活跃期写 /tmp/audio_monitor_<bootts>.log，行含 %uHz/%uch/DoP 与 hwrate/vol。 */
    printf("[T16 monitor logs hi-res/DoP rate+fmt]\n");
    unlink(TSOCK); unlink(TWAV);
    g_audiod_pid = start_audiod();
    usleep(400000);
    {
        struct cli m16;
        check(cli_connect(&m16) == 0, "connect M16");
        /* 先清空 monitor 文件（复用同一 bootts 名；先前测试 T8-T15 已写入大量旧行），
         * 保证下面的检查只针对本 DoP 流新写行（append 模式将在文件尾追加）。 */
        char bootts16[64] = "";
        { int fd = open("/tmp/meow_bootts", O_RDONLY); if (fd >= 0) { ssize_t r = read(fd, bootts16, 63); close(fd); if (r > 0) bootts16[r] = 0; } }
        char mp16[160]; snprintf(mp16, sizeof mp16, "/tmp/audio_monitor_%s.log", bootts16);
        unlink(mp16);
        m_audio_open_ack_t ack16;
        check(do_open_f(&m16, 176400, 2, AUDIO_FMT_DOP, AUDIO_FLAG_DSD, &ack16) == 0 && ack16.err == MEOW_OK,
              "open DoP@176400 for monitor");
        uint8_t dop16[4096];
        size_t fs16 = 2 * 4;
        size_t nd16 = sizeof dop16 / fs16;
        uint8_t *od16 = dop16;
        for (size_t i = 0; i < nd16; i++) {
            uint32_t wl = ((uint32_t)(i & 0xFFFFu) << 16) | (0xFAu << 8);
            uint32_t wr = ((uint32_t)(~i & 0xFFFFu) << 16) | (0x05u << 8);
            memcpy(od16, &wl, 4); od16 += 4; memcpy(od16, &wr, 4); od16 += 4;
        }
        for (int i = 0; i < 12; i++) do_write(&m16, dop16, (uint32_t)sizeof dop16);
        char mb16[4096]; int ml16 = 0;
        for (int i = 0; i < 30; i++) {
            usleep(200000);   /* 等 ≥2 个 1s 节拍写 monitor 行 */
            int fd = open(mp16, O_RDONLY);
            if (fd >= 0) { ml16 = (int)read(fd, mb16, sizeof mb16 - 1); close(fd); if (ml16 > 0) mb16[ml16] = 0; }
            if (ml16 > 0 && strstr(mb16, "176400Hz/2ch/DoP") && strstr(mb16, "dsd=1")) break;
        }
        check(ml16 > 0 && strstr(mb16, "176400Hz/2ch/DoP") && strstr(mb16, "dsd=1"),
              "monitor log records container rate 176400 + fmt DoP + dsd=1");
        do_ctrl(&m16, MSG_AUDIO_STOP, ack16.stream_id);
        close(m16.fd);
    }
    stop_audiod();

    printf("=== SUMMARY: pass=%d fail=%d ===\n", g_pass, g_fail);
    return g_fail ? 1 : 0;
}