ek-ui 0.9.21

//! L3:kittest 官方建构(egui 0.33.3 同版)—— AccessKit 节点断言 + 就地交互 +
//! 本帧绘制指令(形状)判据。人工核查 0 项。
//!
//! 渲染入口与真实 App 同源:[`ek_ui::render_body`](ek_ui::render_body)(L2)。
//!
//! v4 布局钉口径:弹窗(运维/CTP/查询合约/K线)默认关闭 —— 需要弹窗内容的
//! 钉先 `set_*_window_open(true)` 再建构(菜单点击流程另有 s17 钉走 UI 面)。
//! 右下组默认「资金」tab —— 日志面钉先 `set_bottomright_tab(Logs)`。
//! 可达性教训(BD-UI-27/D7):AccessKit 可见 ≠ 视觉可达 —— 内容钉配带内滚动面
//! (auto_shrink=false),「画出来没有标签」的东西一律回到这一帧的绘制指令核
//! (`FullOutput.shapes`:实心矩形 / 线段 / 文字形状 + 裁剪矩形),不看位图。

use std::sync::Arc;

use egui_kittest::{
    Harness,
    kittest::{By, NodeT, Queryable},
};
use ek_station::wire::PlugRow;
use ek_ui::state::UiCmd;
use ek_ui::{BusSnap, UiShared, render_body};

fn row(name: &str) -> PlugRow {
    PlugRow {
        name: name.to_string(),
        version: "0.1.0".to_string(),
        state: "Running".to_string(),
        deps: vec![],
        spilled: 0,
        panics: 0,
        // 0.7.0 背压刀:水位三读数(夹具零水位,软顶吃 ek-core 缺省)
        pending: 0,
        peak: 0,
        soft_cap: ek_core::plugin::MAILBOX_SOFT_CAP,
    }
}

/// 自定状态行(隔离红标/依赖图用)。
fn row_with(name: &str, state: &str, deps: Vec<String>) -> PlugRow {
    PlugRow {
        name: name.to_string(),
        version: "0.1.0".to_string(),
        state: state.to_string(),
        deps,
        spilled: 0,
        panics: 0,
        pending: 0,
        peak: 0,
        soft_cap: ek_core::plugin::MAILBOX_SOFT_CAP,
    }
}

/// 金样本表(测试面;数字全同源,与 ui_market.rs 的 hand-computed 一致)。
fn golden_bar(dt_s: i64) -> ek_data::bar::BarData {
    ek_data::bar::BarData {
        symbol: "rb2605".to_string(),
        exchange: ek_data::constant::Exchange::SHFE,
        datetime: dt_s * 1_000_000_000,
        interval: Some(ek_data::constant::Interval::MINUTE),
        volume: 18.0,
        open_price: 100.0,
        high_price: 103.0,
        low_price: 99.5,
        close_price: 99.5,
        ..ek_data::bar::BarData::default()
    }
}

/// 喂行情库:2 帧 eBar.(同址更新面)+ 4 条 eBarUpdate. + 1 次回灌登记。
/// (v4:行情带上屏已改 tick 源;此面只供 K线窗格数据。)
fn feed_market_frame(shared: &UiShared, frames_expect: u64, updates_expect: u64) {
    let frame = ek_dm::wire::BarsFrame {
        name: "dm".to_string(),
        interval: 60,
        bars: vec![golden_bar(36_000)],
    };
    shared.market().on_frame(&frame);
    let frame2 = ek_dm::wire::BarsFrame {
        name: "dm".to_string(),
        interval: 60,
        bars: vec![golden_bar(36_060)],
    };
    shared.market().on_frame(&frame2);
    for _ in 0..4 {
        shared.market().on_update(&golden_bar(36_060));
    }
    shared.market().note_reload();
    let (f, u, r) = shared.market().counts();
    assert_eq!(f, frames_expect);
    assert_eq!(u, updates_expect);
    assert_eq!(r, 1);
}

/// 行情带 tick 样本(数字全同源)。
fn tick(
    ex: ek_data::constant::Exchange,
    symbol: &str,
    name: &str,
    last: f64,
    pct: f64,
) -> ek_data::tick::TickData {
    ek_data::tick::TickData {
        gateway_name: "ctp".to_string(),
        symbol: symbol.to_string(),
        exchange: ex,
        datetime: 36_000 * 1_000_000_000,
        name: name.to_string(),
        last_price: last,
        pct_change: pct,
        volume: 1234.0,
        open_price: 100.0,
        high_price: 103.0,
        low_price: 99.0,
        bid_price_1: last - 0.5,
        bid_volume_1: 3.0,
        ask_price_1: last + 0.5,
        ask_volume_1: 4.0,
        update_time: "10:00:00".to_string(),
        ..ek_data::tick::TickData::default()
    }
}

/// 查询合约窗样本行。
fn contract(
    ex: ek_data::constant::Exchange,
    symbol: &str,
    name: &str,
) -> ek_data::contract::ContractData {
    ek_data::contract::ContractData {
        gateway_name: "ctp".to_string(),
        symbol: symbol.to_string(),
        exchange: ex,
        name: name.to_string(),
        asset: ek_data::constant::Asset::default(),
        instrument_type: None,
        size: 10.0,
        price_tick: 1.0,
        product_id: None,
        max_limit_order_volume: None,
        min_limit_order_volume: None,
        max_market_order_volume: None,
        min_market_order_volume: None,
        delivery_year: None,
        delivery_month: None,
        open_date: None,
        pre_close: None,
        up_stop_price: None,
        down_stop_price: None,
        float_volume: None,
        total_volume: None,
        instrument_status: None,
        is_trading: None,
    }
}

fn demo_rows() -> Vec<PlugRow> {
    vec![row("svctl"), row("dm"), row("oms"), row("ui")]
}

/// 多账号面测试种子:注册一个账户行并指定为行情源(订阅路由的前置条件)。
/// 回带派生注册名(= 订阅 cmd 的 gateway 位)。
fn seed_md_source(shared: &UiShared, broker: &str, account: &str) -> String {
    let form = ek_ui::state::CtpForm {
        broker_id: broker.to_string(),
        td_user: account.to_string(),
        ..Default::default()
    };
    let row = ek_ui::state::AccountRow::derive(&form).expect("派生注册名");
    shared.add_account(row.clone()).expect("添加账户");
    shared.set_md_source(&row.gateway).expect("指定行情源");
    row.gateway
}

/// 四态测试种子:把某账户标成「已装配」——等价于插件侧拿 svctl.list 快照回写
/// (`sync_accounts_connected`:名字在场 → `Assembled` + 在场位真)。
/// 0.2.18 起 `default_gateway()` 只认已装配账户(规划 Q4),需要默认网关的测试先走这一步。
fn mark_assembled(shared: &UiShared, gateway: &str) {
    shared.sync_accounts_connected(&[row(gateway)]);
}

/// 本帧画出来的**全部形状**(含所有图层:toast 画在 Foreground 层,也在其中)。
///
/// 口径(HANDOVER §17,本轮定死):判据看「这一帧画了什么形状、画在哪、什么颜色」,
/// 不看位图 —— `harness.render()` 取像素、`harness.snapshot()` 比基线这两条已作废,
/// 本机既没有截图也没有读图能力。形状来自 `egui::FullOutput.shapes`,是 immediate
/// 模式这一帧的真实绘制指令:确定性、可比、不需要眼睛。
fn shapes_of(harness: &Harness<'_>) -> Vec<egui::Shape> {
    harness
        .output()
        .shapes
        .iter()
        .map(|c| c.shape.clone())
        .collect()
}

/// 本帧形状 + 各自的裁剪矩形(判据要问「这一帧真画出来没有」时用这个)。
fn clipped_shapes_of(harness: &Harness<'_>) -> Vec<egui::epaint::ClippedShape> {
    harness.output().shapes.clone()
}

/// 某色的**实心矩形**(表头带 / tab 头底 / toast 底都是 `rect_filled`)。
/// 某支颜色写的**文字形状**(涨/跌色落屏判据用:`RichText::color` 走 override 或 section 色)。
fn text_shapes_of_color(shapes: &[egui::Shape], color: egui::Color32) -> Vec<String> {
    shapes
        .iter()
        .filter_map(|s| match s {
            egui::Shape::Text(t) if text_color_of(t) == color => Some(t.galley.text().to_string()),
            _ => None,
        })
        .collect()
}

/// 某支颜色画的**任意形状**(线/柱/填充都算:图表涨跌色落屏判据用)。
fn any_shapes_of_color(shapes: &[egui::Shape], color: egui::Color32) -> Vec<egui::Shape> {
    shapes
        .iter()
        .filter_map(|s| match s {
            egui::Shape::LineSegment { stroke, .. } if stroke.color == color => Some(s.clone()),
            egui::Shape::Rect(r) if r.fill == color || r.stroke.color == color => Some(s.clone()),
            egui::Shape::Text(t) if text_color_of(t) == color => Some(s.clone()),
            _ => None,
        })
        .collect()
}
fn filled_rects(shapes: &[egui::Shape], color: egui::Color32) -> Vec<egui::Rect> {
    shapes
        .iter()
        .filter_map(|s| match s {
            egui::Shape::Rect(r) if r.fill == color && r.stroke.is_empty() => Some(r.rect),
            _ => None,
        })
        .collect()
}

/// 某色的**横线**(`hline` → `Shape::LineSegment`,取水平的那些):返回 (y, x 范围)。
fn hlines(shapes: &[egui::Shape], color: egui::Color32) -> Vec<(f32, egui::Rangef)> {
    shapes
        .iter()
        .filter_map(|s| match s {
            egui::Shape::LineSegment { points, stroke }
                if stroke.color == color
                    && !stroke.is_empty()
                    && (points[0].y - points[1].y).abs() < 0.5 =>
            {
                Some((points[0].y, egui::Rangef::new(points[0].x, points[1].x)))
            }
            _ => None,
        })
        .collect()
}

/// **任意颜色**的竖线(0.4.1 七期 BD-UI-60 的反向钉用):列线撤除后,「表里没有竖线」
/// 这条判据不能只盯 `BORDER` 一色 —— 把描边换个颜色就糊过去了。
fn vlines_any(shapes: &[egui::Shape]) -> Vec<(f32, egui::Rangef, egui::Color32)> {
    shapes
        .iter()
        .filter_map(|s| match s {
            egui::Shape::LineSegment { points, stroke }
                if !stroke.is_empty() && (points[0].x - points[1].x).abs() < 0.5 =>
            {
                Some((
                    points[0].x,
                    egui::Rangef::new(points[0].y, points[1].y),
                    stroke.color,
                ))
            }
            _ => None,
        })
        .collect()
}

/// 文字形状里含 `needle` 的那些:返回 (整串文本, 视觉矩形, 这一串实际用的颜色)。
fn texts_containing(
    shapes: &[egui::Shape],
    needle: &str,
) -> Vec<(String, egui::Rect, egui::Color32)> {
    shapes
        .iter()
        .filter_map(|s| match s {
            egui::Shape::Text(t) => {
                let text = t.galley.text();
                text.contains(needle)
                    .then(|| (text.to_string(), t.visual_bounding_rect(), text_color_of(t)))
            }
            _ => None,
        })
        .collect()
}

/// 一串文字实际用的颜色:显式 override 优先,其次 galley 里第一个非 PLACEHOLDER
/// 的 section 色,最后才是 painter 的兜底色。
fn text_color_of(t: &egui::epaint::TextShape) -> egui::Color32 {
    if let Some(c) = t.override_text_color {
        return c;
    }
    for section in &t.galley.job.sections {
        if section.format.color != egui::Color32::PLACEHOLDER {
            return section.format.color;
        }
    }
    t.fallback_color
}

fn monospace_at(harness: &Harness<'_>, needle: &str, at: &egui::Rect) -> Option<bool> {
    let probe = at.shrink(2.0);
    shapes_of(harness)
        .iter()
        .filter_map(|sh| match sh {
            egui::Shape::Text(t) if t.galley.text() == needle => {
                t.visual_bounding_rect().intersects(probe).then(|| {
                    t.galley
                        .job
                        .sections
                        .iter()
                        .all(|sec| matches!(sec.format.font_id.family, egui::FontFamily::Monospace))
                })
            }
            _ => None,
        })
        .next()
}

/// 填一次固定快照(svctl.list 形状)。
fn feed_snapshot(shared: &UiShared, services: Vec<(String, Vec<String>)>) {
    shared.set_snapshot(BusSnap {
        rows: demo_rows(),
        services,
    });
}

/// 建构钉统一实窗尺寸(v5 = 1280×860,runtime.rs 同源)。
/// (D7 教训:800×600 缺省建构面与实窗不符,带内折叠口径失真。
/// BD-UI-29 面板化后走 ctx 级建构 `build`(render_body 自开顶层面板,
/// 不得再包 CentralPanel —— panel.rs 官方纪律)。)
fn harness_for(shared: &UiShared) -> Harness<'_> {
    Harness::builder()
        .with_size([1280.0, 860.0])
        .build(|ctx| render_body(ctx, shared))
}

/// **宽夹具**(2600×900):判据问的是「这一格在不在、内容对不对」,而 egui_table 的
/// 体表按视口剔除列 —— `region_ui` 的 `col_range` 由 `ui.clip_rect()` 推出来
/// (table.rs:633-648),**滚出视口的格连 delegate 都不调 → 不进语义树**(旧
/// TableBuilder 是全列都建构,裁不裁都在树里)。1280 宽时成交格只有 ~480 px,
/// 17 列的委托表装不下 → 判据要读的那一列就在裁剪外。
/// 所以这类钉换一副宽夹具:两张表都不横向裁剪,语义树里就是全列。
/// (F1 早就这么写了 —— 换库之后这条从「可选」变成「必须」。判据不假设用户屏幕:
/// 这是夹具参数,不是实窗尺寸。)
fn harness_wide_for(shared: &UiShared) -> Harness<'_> {
    Harness::builder()
        .with_size([2600.0, 900.0])
        .build(|ctx| render_body(ctx, shared))
}

// (0.3.x 口径变更:SNAP_LOCK / ensure_wgpu_backend / snap / snap_budget / snap_guard
//  这一整套「像素快照 + wgpu 回读」的脚手架已撤除 —— 判据改走语义树 + 形状 + 状态 +
//  源码扫描,见文件顶部 `shapes_of` 与 HANDOVER §17。)

#[test]
fn s0_rows_and_service_directory_visible() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = Arc::new(UiShared::new());
    feed_snapshot(
        &shared,
        vec![
            (
                "svctl".to_string(),
                vec![
                    "svctl.list".to_string(),
                    "svctl.start".to_string(),
                    "svctl.remove".to_string(),
                ],
            ),
            ("dm".to_string(), vec!["dm.reload".to_string()]),
            ("oms".to_string(), vec!["oms.query".to_string()]),
            ("ui".to_string(), vec![]),
        ],
    );
    // v4:插件/服务面收纳在运维窗;日志钮在右下组「日志」tab。
    shared.set_ops_window_open(true);
    shared.set_bottomright_tab(ek_ui::state::BottomRightTab::Logs);

    let mut harness = harness_for(&shared);

    // 插件表四行:逐行名称标签可查询;不存在的行查不到。
    assert!(harness.query_by_label("dm").is_some());
    assert!(harness.query_by_label("oms").is_some());
    assert!(harness.query_by_label("ui").is_some());
    assert!(harness.query_by_label("ghost").is_none());
    // 状态列:四行同显 Running(准确计数,不是"至少一个")。
    assert_eq!(harness.get_all_by_label("Running").count(), 4);

    // 服务目录:三口逐 id 成行(首列 ="{名}服务",多口同名 → 精确计数);"ui"无服务占位一行。
    assert_eq!(harness.get_all_by_label("svctl 服务").count(), 3);
    assert!(harness.query_by_label("svctl.list").is_some());
    assert!(harness.query_by_label("svctl.start").is_some());
    assert!(harness.query_by_label("svctl.remove").is_some());
    assert!(harness.query_by_label("dm 服务").is_some());
    assert!(harness.query_by_label("dm.reload").is_some());
    assert!(harness.query_by_label("oms.query").is_some());
    assert!(harness.query_by_label("ui 服务").is_some());
    assert!(
        harness.query_all_by_label_contains("清空日志").count() == 0,
        "日志面不得再有「清空日志」钮(0.4.1 用户裁定 2026-10-22:这个钮撤除)"
    );

    harness.run(); // 至少一帧无 panic
}

/// s1(0.4.1 改口径):日志面**没有**「清空日志」钮(用户裁定 2026-10-22 撤除),
/// 但日志行本身照常在格内成表。状态层的清空口另有 `ui_state.rs::r3` 钉。
#[test]
fn s1_log_surface_has_no_clear_button() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = Arc::new(UiShared::new());
    feed_snapshot(&shared, vec![]);
    shared.set_bottomright_tab(ek_ui::state::BottomRightTab::Logs);
    shared.log_line("[INFO][demo] 样例 001");
    shared.log_line("[WARN][demo] 样例 002");
    shared.log_line("[INFO][demo] 样例 003");

    let mut harness = harness_for(&shared);
    harness.run();
    assert_eq!(shared.logs_len(), 3);

    // ① 钮不得在场(整窗范围查,不限日志格)。
    assert_eq!(
        harness.query_all_by_label_contains("清空日志").count(),
        0,
        "「清空日志」钮必须已从界面撤除"
    );
    // ② 但日志内容还在(撤钮不得连带把日志面撤掉)。
    for needle in ["样例 001", "样例 002", "样例 003"] {
        assert!(
            harness.query_all_by_label_contains(needle).next().is_some(),
            "日志行「{needle}」必须还在表里"
        );
    }
    // ③ 表头两列(时间/信息)还在。
    for needle in ["时间", "信息"] {
        assert!(
            harness.query_all_by_label_contains(needle).next().is_some(),
            "日志表头「{needle}」必须还在"
        );
    }
}

#[test]
fn s2_log_lines_rendered_with_text() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = Arc::new(UiShared::new());
    feed_snapshot(&shared, vec![]);
    shared.set_bottomright_tab(ek_ui::state::BottomRightTab::Logs);
    shared.log_line("[INFO][demo] 固定样例行 甲");
    shared.log_line("[INFO][demo] 固定样例行 乙");

    let harness = harness_for(&shared);
    // 日志正文以 Label 呈现,按包含查询命中。
    assert!(harness.query_by_label_contains("固定样例行 甲").is_some());
    assert!(harness.query_by_label_contains("固定样例行 乙").is_some());
}

/// 静态布局首帧钉(0.4.0 整窗 dock 化;只含静态内容:固定行 + 固定日志,无实时数据路径)。
///
/// **结构口径 = Python 主窗框架**(`mainwindow.py:340-373`):行情带横跨**整个窗宽**压在最上,
/// 下带里「下单(≈300 px)| 数据区」左右分,数据区再 2×2。判据全部取 AccessKit 节点矩形:
/// - 行情格空态文案贴着窗口左沿(x < 40)→ 证明确实横跨全宽(0.4.0 第一版这里 x≈300,
///   因为下单通高把左边一列吃掉了 —— 用户说的「你把之前的布局修改了」);
/// - 下单格「全撤」在下带左侧(x < 300 且**在行情带之下**)→ 证明下单只占下带左列;
/// - 委托/成交/持仓/资金四格的表头与空态锚点 → 证明 2×2 与右列贴边。
///
/// dbg 实锤的机制回归(horizontal 行不吃满高度 → 定高失效 → 死区)会直接把底行拉回 y<500,
/// 本钉当场抓住。框架画没画出来另有一条形状钉(本帧绘制指令里必须出现整行表头带),不看位图。
#[test]
fn s3_static_layout_frame() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = Arc::new(UiShared::new());
    feed_snapshot(
        &shared,
        vec![
            (
                "svctl".to_string(),
                vec![
                    "svctl.list".to_string(),
                    "svctl.start".to_string(),
                    "svctl.remove".to_string(),
                ],
            ),
            ("dm".to_string(), vec!["dm.reload".to_string()]),
            ("oms".to_string(), vec![]),
            ("ui".to_string(), vec![]),
        ],
    );
    // 首帧保持默认树(资金格在前台);日志格改到本钉末尾切过去 —— 那里正是「切格」这条判据。
    shared.log_line("[INFO][demo] 固定样例行 001");
    shared.log_line("[INFO][demo] 固定样例行 002");
    shared.log_line("[INFO][demo] 固定样例行 003");

    let mut harness = harness_for(&shared);
    harness.run();

    // ---- 结构钉(1280×860 实窗尺寸;全部取 AccessKit 矩形,不看位图) ----
    let rect_of = |label: &str| {
        harness
            .query_by_label(label)
            .unwrap_or_else(|| panic!("结构钉:{label} 必须存在"))
            .rect()
    };
    // 0.4.0 的锚点换成**格内容**(dock tab 标签不进 AccessKit);0.4.1 六期(BD-UI-59)
    // 起空态不再画提示行 → 锚点一律用**表头列名**:
    // 下单格 = 全撤钮;行情带 = 首列表头「代码」(y < 120 把它与下单表单里那个「代码」
    // 字段标签分开);委托 = 委托表头;成交/持仓 = 各自独有表头;资金 = 余额(只在资金表有)。
    let cancel_all = rect_of("全撤");
    let market = harness
        .query_all_by_label("代码")
        .map(|n| n.rect())
        .find(|r| r.min.y < 120.0)
        .unwrap_or_else(|| panic!("结构钉:行情带首列表头「代码」必须存在"));
    // 数据区的两个「表左沿」锚点:委托表 / 成交表的**第一列**表头(代码)。
    // 注意①下单表单里也有一个「代码」字段标签(x < 300)→ 先按 x 过滤;
    // ②「代码」在数据区里出现三次(委托/成交/持仓)→ 按 x 排序取前两个。
    let mut codes: Vec<egui::Rect> = harness
        .query_all_by_label("代码")
        .map(|n| n.rect())
        .filter(|r| r.min.x > 300.0)
        .collect();
    codes.sort_by(|a, b| {
        (a.min.y, a.min.x)
            .partial_cmp(&(b.min.y, b.min.x))
            .expect("可比")
    });
    // 上排两张表(委托左上 / 成交右上):左半那张 + 右半那张。
    let order_hdr = codes
        .iter()
        .copied()
        .find(|r| r.min.x < 700.0)
        .expect("结构钉:委托表头必须存在");
    let trades_hdr = codes
        .iter()
        .copied()
        .find(|r| r.min.x > 700.0)
        .expect("结构钉:成交表头必须存在");
    let trades = rect_of("成交金额");
    let pos = rect_of("均价");
    let funds = rect_of("权益");

    assert!(
        (cancel_all.min.x - 168.0).abs() < 40.0 && cancel_all.min.y > 400.0,
        "下单格在下带的左列(≈300 px 宽,下带里),实测 {:.0},{:.0}",
        cancel_all.min.x,
        cancel_all.min.y
    );
    assert!(
        market.min.x < 40.0 && market.min.y < 120.0,
        "行情带横跨整个窗宽(贴窗口左沿、菜单条之下),实测 {:.0},{:.0} —— \
         这里 x 变大就说明左边又被「下单通高」吃掉了",
        market.min.x,
        market.min.y
    );
    assert!(
        cancel_all.min.y > market.min.y + 150.0,
        "下单格必须在行情带**之下**(Python 框架:行情带横跨全宽,下带里才有下单),\
         实测 全撤 y={:.0} 行情 y={:.0}",
        cancel_all.min.y,
        market.min.y
    );
    assert!(
        order_hdr.min.x > 280.0 && order_hdr.min.y < 500.0,
        "委托格在数据区左上"
    );
    assert!(
        order_hdr.min.y > market.min.y,
        "行情格压在数据区之上(上 32% / 下 68%)"
    );
    assert!(trades.min.x > 700.0, "成交格在右列(响应式第二列存在)");
    assert!(
        funds.min.x > 700.0 && funds.max.x < 1280.0,
        "资金格在右列且贴边不裁切"
    );
    assert!(
        pos.min.y > 500.0 && funds.min.y > 500.0,
        "底行沉到数据区下部(响应式吃满高度,无死区;定高回归时此处 <500);实测 pos.y={:.0} funds.y={:.0}",
        pos.min.y,
        funds.min.y
    );
    assert!(
        pos.min.y < 760.0 && funds.min.y < 760.0,
        "底行在窗内(不溢出窗口)"
    );
    let col_w = trades_hdr.min.x - order_hdr.min.x;
    assert!(
        (450.0..=540.0).contains(&col_w),
        "两列等宽且随窗口分配(实测列距 {col_w:.0},期望 ≈ (可用宽-间距)/2)"
    );

    // 框架面到底画没画:看这一帧的绘制指令里有没有表头带实心矩形(填充 = BG4)。
    // (这里原来是一张像素快照 `s3_static_layout` —— 快照口径已撤除,见文件顶部说明。)
    let shapes = shapes_of(&harness);
    let bands = filled_rects(&shapes, ek_ui::tokens::shadcn::BG4);
    assert!(
        bands.iter().any(|r| r.width() > 100.0),
        "首帧必须真的画出整行表头带(填充色 = BG4),实测 {bands:?}"
    );

    // 格子切换(0.4.0:同级 tab 在 dock 条上,由状态口切前台):资金格换日志格后
    // 日志正文上屏、资金空态让位 —— 这是「一个格子一个前台 tab」的直接证据。
    shared.set_bottomright_tab(ek_ui::state::BottomRightTab::Logs);
    harness.run();
    for line in ["固定样例行 001", "固定样例行 002", "固定样例行 003"] {
        assert!(
            harness.query_by_label_contains(line).is_some(),
            "切到日志格后 {line} 必须上屏"
        );
    }
    assert!(
        harness.query_by_label("权益").is_none(),
        "资金格让位后它的表头「权益」不得还在屏上(同叶只有一个前台 tab;0.4.1 六期 BD-UI-59 起空态没有提示行,判据改用表头列名;0.8.5 起「余额」改名「权益」)"
    );
}

// ================= S2:svctl 操作面(kittest 流程;v4 收纳运维窗) =================

fn feed_rows(shared: &UiShared, rows: Vec<PlugRow>) {
    shared.set_snapshot(BusSnap {
        rows,
        services: vec![],
    });
}

/// S2 流程:移除走二次确认(首点 armed 无指令 → 二点发令)。
#[test]
fn s4_remove_two_step_confirm_flow() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = Arc::new(UiShared::new());
    feed_rows(&shared, vec![row("svctl"), row("dm")]);
    shared.set_ops_window_open(true);

    let mut harness = harness_for(&shared);

    // 首点:进入待确认(按钮翻确认文案),无指令入队。
    // (0.9.10 光杆化:运维窗钮不带插件名,行带定行 = 名称列单元格)
    click_row_action(&mut harness, "dm", "移除");
    assert_eq!(shared.pending_confirm().as_deref(), Some("dm"));
    assert!(shared.drain_cmds().is_empty(), "armed must not enqueue");
    assert!(harness.query_by_label_contains("待二次确认").is_some());
    assert!(row_action_exists(&harness, "dm", "确认移除?"));

    // 二点:发令 + 待确认清空。
    click_row_action(&mut harness, "dm", "确认移除?");
    harness.run();
    assert_eq!(shared.pending_confirm(), None);
    assert_eq!(
        shared.drain_cmds(),
        vec![UiCmd::Remove {
            name: "dm".to_string(),
        }]
    );
    // 横幅消失。
    assert!(harness.query_by_label_contains("待二次确认").is_none());
}

/// S2 流程:重注入单步直发。
#[test]
fn s5_restart_direct_enqueue() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = Arc::new(UiShared::new());
    feed_rows(&shared, vec![row("oms")]);
    shared.set_ops_window_open(true);
    let mut harness = harness_for(&shared);

    click_row_action(&mut harness, "oms", "重注入");
    assert_eq!(
        shared.drain_cmds(),
        vec![UiCmd::Start {
            factory: "oms".to_string(),
            name: String::new(),
        }]
    );
}

/// S2:取消确认钮 + 隔离红标 + 依赖图文本。
#[test]
fn s6_cancel_confirm_quarantine_deps() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = Arc::new(UiShared::new());
    feed_rows(
        &shared,
        vec![
            row_with("dice", "Quarantined", vec![]),
            row_with("p2", "Running", vec!["p1".to_string()]),
        ],
    );
    shared.set_ops_window_open(true);
    let mut harness = harness_for(&shared);

    // 取消待确认:armed → 取消钮 → 待确认清空(按钮回原文案)。
    click_row_action(&mut harness, "dice", "移除");
    assert_eq!(shared.pending_confirm().as_deref(), Some("dice"));
    harness.get_by_label("取消确认").click_accesskit();
    harness.run();
    assert_eq!(shared.pending_confirm(), None);
    assert!(row_action_exists(&harness, "dice", "移除"));

    // 隔离红标:状态字样在场(着色为视觉面;状态机侧 is_quarantined 见 L1)。
    assert!(harness.query_by_label("Quarantined").is_some());

    // 依赖图文本:p2 → p1 在场;无依赖段不显示"全部无依赖"。
    assert!(harness.query_by_label_contains("p2 → p1").is_some());
    assert!(harness.query_by_label_contains("全部无依赖").is_none());
}

/// S3 行情格(0.4.0):tick 行逐位 + **每个交易所一格**(不再是一条二级 tab 条)+ 空态占位。
#[test]
fn s8_market_band_tick_rows() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = Arc::new(UiShared::new());
    feed_rows(&shared, demo_rows());
    shared.update_tick(&tick(
        ek_data::constant::Exchange::SHFE,
        "rb2605",
        "螺纹钢2605",
        101.0,
        1.25,
    ));
    shared.update_tick(&tick(
        ek_data::constant::Exchange::SHFE,
        "au2706",
        "黄金2706",
        777.0,
        -0.5,
    ));
    shared.update_tick(&tick(
        ek_data::constant::Exchange::DCE,
        "a2709",
        "黄玉米2709",
        2222.0,
        0.0,
    ));

    // 默认前台 = SHFE(第一格);把 DCE 格切到前台看 DCE 的行。
    let mut harness = harness_for(&shared);
    // 状态行「tick N 格 / 最后更新」已撤(BD-UI-35 用户裁定)——反向钉:此文字不得再上屏。
    assert!(
        harness.query_by_label_contains("tick 3 格").is_none(),
        "状态行已撤,不得回归"
    );
    assert_eq!(shared.selected_exchange(), "SHFE", "默认前台 = 第一所");
    assert!(harness.query_by_label("rb2605").is_some(), "SHFE 格上屏");
    // SHFE 两行(rb2605 / au2706)都是同一夹具 tick:成交量 1234、时间 10:00:00 各两处。
    assert_eq!(harness.get_all_by_label("101").count(), 1, "最新价列");
    assert_eq!(harness.get_all_by_label("1234").count(), 2, "成交量列");
    assert_eq!(
        harness.get_all_by_label_contains("10:00:00").count(),
        2,
        "时间列"
    );

    // 换格 = 激活另一所的 dock 格(DCE):DCE 行上屏,SHFE 行随之离场。
    shared.set_selected_exchange("DCE");
    harness.run();
    assert!(harness.query_by_label("a2709").is_some());
    assert!(harness.query_by_label_contains("黄玉米2709").is_some());
    assert_eq!(harness.get_all_by_label("2222").count(), 1, "最新价列");
    assert!(harness.query_by_label("rb2605").is_none(), "非前台格不上屏");

    // 行单击 = 带入下单面板(方案「行单击 = 选中合约」落地,ek 增值钉)。
    harness.get_by_label("a2709").click_accesskit();
    harness.run();
    let f = shared.order_form();
    assert_eq!(f.symbol, "a2709", "单击带入代码");
    assert_eq!(f.exchange, "DCE", "单击带入交易所");

    // 0.4.1 六期(BD-UI-59)反向钉:切到没有 tick 的所,表头照在、**提示词不许有**
    // (旧口径画一句「(等待该所 eTick 订阅)」,用户裁定撤除:表体就是空的)。
    shared.set_selected_exchange("CZCE");
    harness.run();
    assert!(
        harness.query_all_by_label_contains("最新价").count() >= 1,
        "空态不得吞表头:CZCE 行情格的表头必须在"
    );
    assert_eq!(
        harness
            .query_all_by_label_contains("等待该所 eTick 订阅")
            .count(),
        0,
        "空态提示词已退役(0.4.1 六期 BD-UI-59):这一拍 CZCE 表体必须是空的"
    );
}

/// S4 K线窗钉:open_kline → 窗内标题在场 + 状态里这根窗真开着 + 图表色板走我们的令牌。
/// (原来这里是一张首帧快照 `s10_kline_first_frame` —— 快照口径已撤除;图表画没画成
/// 现在钉的是「ChartConfig 必须显式覆盖成我们的令牌 / 红涨绿跌」这条源码机械扫描,
/// 它挡的正是 0.2.30 实撞过的错法:egui_charts 自带 TradingView 色板,涨跌方向相反。)
#[test]
fn s10_kline_window_opens_with_header() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = Arc::new(UiShared::new());
    feed_rows(&shared, demo_rows());
    feed_market_frame(&shared, 2, 4);
    shared.open_kline("rb2605");
    let mut harness = harness_for(&shared);
    assert!(
        harness
            .query_by_label_contains("K线 rb2605@60s(2 根)")
            .is_some(),
        "kline window header missing"
    );
    harness.run();
    assert!(
        shared.kline_symbols().iter().any(|s| s == "rb2605"),
        "K线窗必须在状态层里真开着(kline_symbols),实测 {:?}",
        shared.kline_symbols()
    );
    let render_src = std::fs::read_to_string(concat!(env!("CARGO_MANIFEST_DIR"), "/src/render.rs"))
        .expect("render.rs 必须可读");
    // 0.8.0 双档(BD-UI-61):K线五支必须**跟当前档**(判据 s93 钉画面,这条钉字面形状)。
    // 旧字面串钉的是「深档常量直写」—— 那正是浅档下 K 线成为界面里唯一一块黑底的写法,
    // 判据对象随改判换新串,并加三支「禁用深档常量直写」。
    for needle in [
        "bullish_color: crate::tokens::rise(ui.ctx())",
        "bearish_color: crate::tokens::fall(ui.ctx())",
        "let pal = crate::tokens::palette(ui.ctx());",
        "background_color: pal.bg1",
        "grid_color: pal.border",
        "text_color: pal.text1",
    ] {
        assert!(
            render_src.contains(needle),
            "K线图表色板必须显式覆盖成**当前档**的令牌(缺「{needle}」= 又用回自带色板,或把深档常量写死了)"
        );
    }
    for banned in [
        "background_color: crate::tokens::shadcn::BG1",
        "grid_color: crate::tokens::shadcn::BORDER",
        "text_color: crate::tokens::shadcn::TEXT1",
    ] {
        assert!(
            !render_src.contains(banned),
            "K线不许把深档常量写死(浅档就不跟档),实测还挂着「{banned}」"
        );
    }
}

/// s10b(F1 键统一,0.9.9):两件事一并钉住——
/// 1)「在途中」诚实显形:开窗无格时写明 tq 历史补数在途(不许静默空图);
/// 2)剥前缀命中:note_history 按带交易所前缀收格(如 SHFE.rb2605),
///   窗口以裸符号查找也命中 —— E15 波前的病窗(存键带前缀/查键裸)就此关闭。
#[test]
fn s10b_kline_prefix_key_lookup_and_inflight_hint() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = Arc::new(UiShared::new());
    feed_rows(&shared, demo_rows());
    shared.open_kline("rb2605");

    // 1) 在途显形(格未到)。
    let mut harness = harness_for(&shared);
    harness.run();
    assert!(
        harness
            .query_by_label_contains("tq 历史补数在途")
            .is_some(),
        "开窗无格必须显形『补数在途』(不许静默空图)"
    );

    // 2) 带前缀键收格 → 窗查找剥前缀命中。
    let mut b = golden_bar(36_000);
    b.symbol = "SHFE.rb2605".to_string();
    let mut b2 = golden_bar(36_060);
    b2.symbol = "SHFE.rb2605".to_string();
    shared.market().note_history("SHFE.rb2605", 60, &[b, b2]);
    shared.bump();
    let mut harness = harness_for(&shared);
    harness.run();
    assert!(
        harness
            .query_by_label_contains("K线 SHFE.rb2605@60s(2 根)")
            .is_some(),
        "裸符号窗必须经剥前缀命中带前缀格(旧病:存键带前缀/查键裸 → 永远空图)"
    );
}

/// S5 交易监控格:TradeSnap 帧 → 委托/成交/持仓读数逐位 + 活动行撤单钮入列。
#[test]
fn s11_trade_monitor_rows() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = Arc::new(UiShared::new());
    feed_rows(&shared, demo_rows());
    let mut active = ek_data::order::OrderData {
        gateway_name: "ctp".to_string(),
        symbol: "rb2605".to_string(),
        exchange: ek_data::constant::Exchange::SHFE,
        orderid: "CTP_0_1".to_string(),
        direction: Some(ek_data::constant::Direction::LONG),
        offset: ek_data::constant::Offset::OPEN,
        price: 102.5,
        volume: 10.0,
        status: ek_data::constant::Status::SUBMITTING,
        ..ek_data::order::OrderData::default()
    };
    let done = ek_data::order::OrderData {
        orderid: "CTP_0_2".to_string(),
        traded: 8.0,
        traded_price: 102.5,
        status: ek_data::constant::Status::ALLTRADED,
        ..active.clone()
    };
    active.traded = 4.0;
    active.status = ek_data::constant::Status::PARTTRADED;
    shared.seed_trade_snap(ek_ui::state::TradeSnap {
        orders: vec![active, done],
        trades: vec![ek_data::trade::TradeData {
            gateway_name: "ctp".to_string(),
            symbol: "rb2605".to_string(),
            exchange: ek_data::constant::Exchange::SHFE,
            orderid: "CTP_0_2".to_string(),
            tradeid: "T1".to_string(),
            direction: Some(ek_data::constant::Direction::LONG),
            offset: ek_data::constant::Offset::OPEN,
            price: 102.5,
            volume: 8.0,
            datetime: Some(36_000_000_000_000),
            ..ek_data::trade::TradeData::default()
        }],
        positions: vec![ek_data::position::PositionData {
            gateway_name: "ctp".to_string(),
            symbol: "rb2605".to_string(),
            exchange: ek_data::constant::Exchange::SHFE,
            direction: ek_data::constant::Direction::LONG,
            volume: 18.0,
            avg_price: 102.5,
            ..ek_data::position::PositionData::default()
        }],
        accounts: vec![],
    });
    // 本钉用 step_dt=0.1 建构(kittest 每事件一帧,缺省 0.25s 会把两击间隔拉到
    // 0.5s > egui max_double_click_delay 0.3s,双击检测失真;0.1s 下两击 0.2s,
    // 与真实用户双击同路径。其余断言与 step_dt 无关)。
    // 宽夹具(BD-UI-55):判据读的是委托表第 14 列「委托号」(双击撤单的落点行),
    // 1280 宽时这一列在横向裁剪外,egui_table 不建构裁剪外的格 → 读不到(见
    // `harness_wide_for`)。0.8.5 起「操作」撤单钮列已删(用户裁定),钮判据改为
    // 「必须不存在」。
    let mut harness = Harness::builder()
        .with_size([2600.0, 900.0])
        .with_step_dt(0.1)
        .build(|ctx| render_body(ctx, &shared));
    // 读数与喂入帧逐位一致(get_all_by_label 精确匹配)。
    assert_eq!(harness.get_all_by_label("CTP_0_1").count(), 1, "委托号列");
    assert_eq!(
        harness.get_all_by_label("CTP_0_2").count(),
        2,
        "委托表委托号 + 成交表委托号(T1 挂 CTP_0_2)"
    );
    assert!(harness.query_by_label_contains("PARTTRADED").is_some());
    assert!(harness.query_by_label_contains("ALLTRADED").is_some());
    assert!(harness.query_by_label_contains("SUBMITTING").is_none());
    assert_eq!(
        harness.get_all_by_label("102.5").count(),
        5,
        "委托价×2 + 成交均价×1 + 成交价×1 + 持仓成本×1(0.3.3 起持仓成本走 format::price,不再是 102.50)"
    );
    // 2026-10-28 用户裁定:17 列的「操作」撤单钮列删除 —— 撤单走行双击
    // (Python OrderMonitor itemDoubleClicked 等价)与面板「全撤」。判据随之改向:
    // ① 行级撤单钮**必须不存在**(删了列还留钮 = 回归);
    assert!(
        harness
            .query_by_label_contains(ek_ui::render::BTN_CANCEL_ORDER)
            .is_none(),
        "委托表行内「撤单」钮必须不存在(2026-10-28 裁定撤列;若它在屏上 = 列又回来了)"
    );
    assert!(harness.query_by_label_contains("T1").is_some());
    // ② 撤单能力走双击,下面仍旧钉着(判据只改路,不改意)。
    // 委托行双击 = 撤单(Python OrderMonitor itemDoubleClicked→cancel_order 等价)。
    // Node 借用 harness 树,先取 rect 再驱动事件(借用检查)。
    let pos = {
        let row = harness.get_all_by_label("rb2605").next().unwrap();
        row.rect().center()
    };
    harness.hover_at(pos);
    harness.step();
    for pressed in [true, false] {
        harness.event(egui::Event::PointerButton {
            pos,
            button: egui::PointerButton::Primary,
            pressed,
            modifiers: egui::Modifiers::default(),
        });
    }
    harness.step();
    assert!(
        shared.drain_cmds().is_empty(),
        "单击委托行不得入列(Python 同口径)"
    );
    for pressed in [true, false] {
        harness.event(egui::Event::PointerButton {
            pos,
            button: egui::PointerButton::Primary,
            pressed,
            modifiers: egui::Modifiers::default(),
        });
    }
    harness.step();
    let cmds2 = shared.drain_cmds();
    assert!(
        matches!(&cmds2[..], [ek_ui::state::UiCmd::CancelOrder { orderid, .. }] if orderid == "CTP_0_1"),
        "双击撤单入列失败: {cmds2:?}"
    );
}

/// v4 下单面板(OrderForm 面):好单 → SendOrder 入列逐位;坏价 → 红字 + 不入列。
/// (票据 TicketForm 已退役;解析断言另有 ui_state r7。)
#[test]
fn s12_order_panel_submit() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = Arc::new(UiShared::new());
    feed_rows(&shared, demo_rows());
    shared.set_order_form(ek_ui::state::OrderForm {
        exchange: "SHFE".to_string(),
        symbol: "rb2605".to_string(),
        direction: ek_data::constant::Direction::LONG,
        offset: ek_data::constant::Offset::OPEN,
        order_type: ek_data::constant::OrderType::LIMIT,
        price: "102.5".to_string(),
        volume: "10".to_string(),
        gateway: "ctp".to_string(),
        follow_price: false,
        auto_split: true,
    });
    let mut harness = harness_for(&shared);
    // 「委托」两面同名(Python 口径:下单钮 = 委托,tab = 委托;表题已撤,
    // 第五轮审计)→ get_by_label 必炸;显式钉两面在场,点先渲染的下单钮。
    // 0.4.1(BD-UI-54):tab 条回归原生 selectable_label —— 0.4.0 dock 时代
    // 「tab 不进 AccessKit 只有 1 处」的旧账已清。
    let order_nodes: Vec<_> = harness
        .get_all_by_label(ek_ui::render::BTN_SEND_ORDER)
        .collect();
    assert_eq!(order_nodes.len(), 2, "委托钮 + 委托 tab");
    assert_eq!(
        shared.topleft_tab(),
        ek_ui::state::TopLeftTab::Orders,
        "委托 tab 缺省在前台"
    );
    order_nodes[0].click_accesskit();
    harness.run();
    let cmds = shared.drain_cmds();
    assert_eq!(cmds.len(), 1);
    match &cmds[0] {
        ek_ui::state::UiCmd::SendOrder { req, gateway, mode } => {
            assert_eq!(req.symbol, "rb2605");
            assert_eq!(req.exchange, ek_data::constant::Exchange::SHFE);
            assert_eq!(req.price, 102.5);
            assert_eq!(req.volume, 10.0);
            assert_eq!(req.direction, ek_data::constant::Direction::LONG);
            assert_eq!(gateway, "ctp", "网关选择子随单入列(S6)");
            assert_eq!(
                *mode,
                ek_oms::LockMode::Auto,
                "自动开平默认勾选 = Auto(s22 钉勾选翻转)"
            );
        }
        other => panic!("expected SendOrder, got {other:?}"),
    }
    // 坏价:不入列 + 红字双面(label 点击帧 + 日志跨帧)。
    let mut bad = shared.order_form();
    bad.price = "abc".to_string();
    shared.set_order_form(bad);
    harness.run();
    let bad_nodes: Vec<_> = harness
        .get_all_by_label(ek_ui::render::BTN_SEND_ORDER)
        .collect();
    bad_nodes[0].click_accesskit();
    harness.step(); // 点击帧即停(run() 的后续空闲帧会撤走单帧红字)
    assert!(shared.drain_cmds().is_empty(), "bad form must not enqueue");
    assert!(harness.query_by_label_contains("价格无效").is_some());
    assert!(
        shared
            .logs_snapshot()
            .0
            .iter()
            .any(|l| l.contains("价格无效")),
        "order parse error log missing"
    );
}

/// 0.1.1 BD-UI-30 s22:「自动开平」勾选 → mode 逐位钉(默认勾选 = Auto;
/// 取消勾选 = None 旁路拆单器;勾选双向可逆)。
#[test]
fn s22_auto_split_checkbox_mode() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = Arc::new(UiShared::new());
    feed_rows(&shared, demo_rows());
    shared.set_order_form(ek_ui::state::OrderForm {
        exchange: "SHFE".to_string(),
        symbol: "rb2605".to_string(),
        price: "102.5".to_string(),
        volume: "2".to_string(),
        gateway: "ctp".to_string(),
        follow_price: false,
        ..Default::default()
    });
    let mut harness = harness_for(&shared);
    // 勾选在场(开平行旁,默认已勾)。
    harness.get_by_label("自动开平").click_accesskit();
    harness.run();
    let order_nodes: Vec<_> = harness
        .get_all_by_label(ek_ui::render::BTN_SEND_ORDER)
        .collect();
    order_nodes[0].click_accesskit();
    harness.step();
    let cmds = shared.drain_cmds();
    assert!(
        matches!(
            &cmds[..],
            [ek_ui::state::UiCmd::SendOrder {
                mode: ek_oms::LockMode::None,
                ..
            }]
        ),
        "取消勾选后 mode 应为 None: {cmds:?}"
    );
    // 再勾回 → Auto(勾选双向;表单持久化经 set_order_form)。
    harness.get_by_label("自动开平").click_accesskit();
    harness.run();
    let order_nodes: Vec<_> = harness
        .get_all_by_label(ek_ui::render::BTN_SEND_ORDER)
        .collect();
    order_nodes[0].click_accesskit();
    harness.step();
    let cmds = shared.drain_cmds();
    assert!(
        matches!(
            &cmds[..],
            [ek_ui::state::UiCmd::SendOrder {
                mode: ek_oms::LockMode::Auto,
                ..
            }]
        ),
        "再勾选后 mode 应为 Auto: {cmds:?}"
    );
}

/// 0.2.0 BD-UI-31 s23:表格行选中钉 —— 委托行首格单击 = 选中(每表一行,
/// 换行即换选);成交行首格单击 = 选中(成交表独立槽,不挤委托表选中)。
#[test]
fn s23_row_selection() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = Arc::new(UiShared::new());
    feed_rows(&shared, demo_rows());
    shared.seed_trade_snap(ek_ui::state::TradeSnap {
        orders: vec![
            ek_data::order::OrderData {
                gateway_name: "ctp".to_string(),
                symbol: "rb2605".to_string(),
                exchange: ek_data::constant::Exchange::SHFE,
                orderid: "CTP_0_1".to_string(),
                order_type: ek_data::constant::OrderType::LIMIT,
                direction: Some(ek_data::constant::Direction::LONG),
                offset: ek_data::constant::Offset::OPEN,
                price: 101.0,
                volume: 2.0,
                traded: 0.0,
                traded_price: 0.0,
                status: ek_data::constant::Status::SUBMITTING,
                status_msg: String::new(),
                // 0.11.0 第5刀 C15:名称列缺名时兜底显示代码 → 名称格会多出一个
                // "rb2605" 标签,把本钉的点击序打乱。这里给名字,钉的语义(点代码格
                // 选中行)不变;缺名兜底由 ui_state 的 c15 机械扫描钉把门。
                name: "螺纹钢2605一号".to_string(),
                reference: "P1".to_string(),
                datetime: Some(36_000_000_000_000),
            },
            ek_data::order::OrderData {
                gateway_name: "ctp".to_string(),
                symbol: "rb2605".to_string(),
                exchange: ek_data::constant::Exchange::SHFE,
                orderid: "CTP_1_1".to_string(),
                order_type: ek_data::constant::OrderType::LIMIT,
                direction: Some(ek_data::constant::Direction::SHORT),
                offset: ek_data::constant::Offset::CLOSE,
                price: 102.0,
                volume: 1.0,
                traded: 0.0,
                traded_price: 0.0,
                status: ek_data::constant::Status::SUBMITTING,
                status_msg: String::new(),
                name: "螺纹钢2605二号".to_string(),
                reference: "P2".to_string(),
                datetime: Some(36_001_000_000_000),
            },
        ],
        trades: vec![ek_data::trade::TradeData {
            gateway_name: "ctp".to_string(),
            symbol: "rb2605".to_string(),
            exchange: ek_data::constant::Exchange::SHFE,
            tradeid: "T1".to_string(),
            orderid: "CTP_0_1".to_string(),
            direction: Some(ek_data::constant::Direction::LONG),
            offset: ek_data::constant::Offset::OPEN,
            price: 101.0,
            volume: 2.0,
            traded_amount: 202.0,
            name: "螺纹钢2605成交".to_string(),
            datetime: Some(36_500_000_000_000),
            commission: 0.0,
            slippage: 0.0,
            trade_pnl: 0.0,
        }],
        positions: Vec::new(),
        accounts: Vec::new(),
    });
    // 宽夹具(BD-UI-55):本钉要单击成交表「成交号」格(T1 在第 10 列)—— 1280 宽时
    // 那一列在横向裁剪外,egui_table 不建构裁剪外的格 → 语义树里没有这一颗(见
    // `harness_wide_for`)。
    let mut harness = harness_wide_for(&shared);

    // 委托行 1 单击 → 选中(rb2605 两行 + 成交行代码列同名,取序 0 = 委托行 1)。
    let rows: Vec<_> = harness.get_all_by_label("rb2605").collect();
    rows[0].click_accesskit();
    harness.run();
    assert!(
        shared.row_selected("orders", "ctp.CTP_0_1"),
        "委托行首格单击应选中该行"
    );

    // 委托行 2 单击 → 换选(每表一行;行 1 落选)。
    let row2: Vec<_> = harness.get_all_by_label("rb2605").collect();
    row2[1].click_accesskit();
    harness.run();
    assert!(shared.row_selected("orders", "ctp.CTP_1_1"));
    assert!(!shared.row_selected("orders", "ctp.CTP_0_1"));

    // 成交行首格单击 → 成交表独立槽选中(不挤委托表)。
    harness.get_by_label("T1").click_accesskit();
    harness.run();
    assert!(shared.row_selected("trades", "ctp.T1"));
    assert!(shared.row_selected("orders", "ctp.CTP_1_1"));
}

/// 账户面板(多账号面,规划 §5.B / §5.C + 0.2.18 四态):
/// **『添加账户』只写清册(零指令)**,『连接』才下发(`UiCmd::Connect` 一条做完
/// `svctl.start` + `{gw}.configure`)—— 旧口径"添加即一键装配两令"作废(规划裁定「添加 ≠ 连接」)。
/// 单源纪律钉:**无源且无在场账户 → 首个账户自动指定为元账号(md 前置保留)**;
/// 第二账户按纯 TD 装配(md 位清空,**留档与下发同一份**),元账号不被抢走。
/// 订阅钮仍不在本窗(用户裁定)——订阅面见 s18 查询合约窗钉。
#[test]
fn s13_account_add_enqueue() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = Arc::new(UiShared::new());
    feed_rows(&shared, demo_rows());
    shared.set_accounts_window_open(true);
    let mut harness = harness_for(&shared);
    harness.run();
    // 面板在场,配置弹窗未开(Commit B:『添加账户』= 开弹窗,不再内嵌一张共享表单)。
    assert!(
        harness
            .query_by_label(ek_ui::render::BTN_ACCOUNT_ADD)
            .is_some(),
        "账户面板添加钮在场"
    );
    assert!(!shared.account_edit_open(), "初始:配置弹窗未开");
    assert!(
        harness
            .query_by_label_contains("订阅不在本窗定死")
            .is_none(),
        "Commit B:订阅口径句挪进**配置弹窗**,账户面板不再内嵌表单"
    );
    harness
        .get_by_label(ek_ui::render::BTN_ACCOUNT_ADD)
        .click_accesskit();
    harness.run();
    assert!(
        shared.account_edit_open(),
        "『添加账户』= 开配置弹窗(Commit B 口径)"
    );
    assert!(
        harness.query_by_label("保存").is_some() && harness.query_by_label("保存并连接").is_some(),
        "弹窗须给『保存』与『保存并连接』两个出口(规划 §3.3 四态)"
    );
    assert!(
        harness
            .query_by_label_contains("订阅不在本窗定死")
            .is_some(),
        "订阅撤出配置窗的口径句在场(弹窗内)"
    );
    assert!(shared.accounts().is_empty(), "开弹窗本身不写清册");
    assert!(shared.drain_cmds().is_empty(), "开弹窗不下发任何指令");

    // 弹窗打开后填草稿(开窗会重置草稿位,开窗前填的会被覆盖)。
    shared.set_ctp_form(ek_ui::state::CtpForm {
        broker_id: "9999".to_string(),
        td_addr: "tcp://182.254.243.31:30001".to_string(),
        td_user: "278153".to_string(),
        td_password: "pw-secret".to_string(),
        td_auth_code: "0000000000000000".to_string(),
        td_app_id: "app".to_string(),
        md_addr: "tcp://182.254.243.31:30011".to_string(),
        md_user: String::new(),
        md_password: String::new(),
        symbols: String::new(),
        ..Default::default() // 0.2.12 收录勾选:取缺省(只期货)
    });
    harness.run();
    click_dialog(&mut harness, "保存");
    // ① 四态分离第一钉:『保存』**不下发任何指令**(旧口径"添加即一键装配两令"作废)。
    let cmds = shared.drain_cmds();
    assert!(
        cmds.is_empty(),
        "保存只写清册,不得下发装配/凭据两令: {cmds:?}"
    );
    assert_eq!(shared.accounts().len(), 1, "账户清册落一行");
    assert_eq!(shared.accounts()[0].gateway, "ctp_9999_278153");
    assert_eq!(
        shared.accounts()[0].stage,
        ek_ui::state::AccountStage::NotAssembled,
        "添加后 = 未装配(不是装配中,更不是已装配)"
    );
    assert_eq!(
        shared.md_source(),
        "ctp_9999_278153",
        "无源 + 无在场账户 → 新账户即元账号(§5.C 在添加这一刻定源)"
    );
    assert!(shared.accounts()[0].md_source, "行内元账号标记同步落位");
    assert_eq!(
        shared.accounts()[0].form.md_addr,
        "tcp://182.254.243.31:30011",
        "首个账户 = 元账号 → md 前置必须留档(清掉它 = 它自己也永远收不到 tick)"
    );
    // ② 界面给出『连接』入口(0.9.10 光杆口径:行带里的「连接」,钮不带名)。
    assert!(
        row_action_exists(&harness, "ctp_9999_278153", "连接"),
        "未装配行须有『连接』钮(四态分离的入口)"
    );
    click_row_action(&mut harness, "ctp_9999_278153", "连接");
    let cmds = shared.drain_cmds();
    assert_eq!(cmds.len(), 1, "『连接』= 一条 Connect 令: {cmds:?}");
    match &cmds[0] {
        UiCmd::Connect { gateway, form } => {
            assert_eq!(gateway, "ctp_9999_278153", "连接随派生名寻址");
            assert_eq!(form.broker_id, "9999");
            assert_eq!(form.td_addr, "tcp://182.254.243.31:30001");
            assert_eq!(form.td_user, "278153");
            assert_eq!(
                form.td_password, "pw-secret",
                "密码原值随表单入列(不回显在界面)"
            );
            assert_eq!(
                form.md_addr, "tcp://182.254.243.31:30011",
                "元账号连接时 md 前置保留(§5.C)"
            );
            let req = form.to_configure_req();
            assert_eq!(req.td_app_id, "app");
            assert!(req.md_user.is_empty(), "回落归插件侧裁决,表单不预处理");
        }
        other => panic!("expected Connect, got {other:?}"),
    }

    // 第二账户(同 broker 不同账号):已有元账号 → 按纯 TD 装配,md 位清空,
    // 元账号不被抢走(单源纪律 §5.C)。
    // 注:『保存』后草稿位凭据已清空(s34 口径),所以这里必须自己填 td 前置与密码;
    // broker / AppID / AuthCode 由 `draft_from_existing()` 沿用(规划 Q20 缓解)。
    click_account_add(&mut harness);
    harness.run();
    shared.set_ctp_form(ek_ui::state::CtpForm {
        td_user: "220380".to_string(),
        td_addr: "tcp://182.254.243.31:30001".to_string(),
        td_password: "pw-secret-2".to_string(),
        ..shared.ctp_form()
    });
    harness.run();
    click_dialog(&mut harness, "保存");
    let cmds2 = shared.drain_cmds();
    assert!(cmds2.is_empty(), "第二账户同样『保存不下发』: {cmds2:?}");
    assert_eq!(
        shared.accounts()[1].form.md_addr,
        "",
        "非源账户 md 前置在**留档**里就清空(旧口径只清下发不清留档 → 编辑页会带一根用不上的行情前置)"
    );
    click_row_action(&mut harness, "ctp_9999_220380", "连接");
    let cmds2 = shared.drain_cmds();
    assert_eq!(cmds2.len(), 1, "『连接』一条令: {cmds2:?}");
    match &cmds2[0] {
        UiCmd::Connect { gateway, form } => {
            assert_eq!(
                gateway, "ctp_9999_220380",
                "同 broker 不同账号 = 不同派生名"
            );
            assert_eq!(form.td_user, "220380", "TD 会话各账号独立");
            assert!(
                form.md_addr.is_empty(),
                "非源账户 md 前置一律留空(单源纪律 §5.C)"
            );
        }
        other => panic!("expected Connect, got {other:?}"),
    }
    assert_eq!(
        shared.md_source(),
        "ctp_9999_278153",
        "元账号不被第二账户抢走"
    );
    assert_eq!(shared.accounts().len(), 2, "清册两行");
}

/// S6 资金格(右下组默认 tab):TradeSnap.accounts → 账户行读数逐位;空帧占位行。
#[test]
fn s14_accounts_rows() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = Arc::new(UiShared::new());
    feed_rows(&shared, demo_rows());
    shared.seed_trade_snap(ek_ui::state::TradeSnap {
        accounts: vec![ek_data::account::AccountData {
            gateway_name: "ctp".to_string(),
            accountid: "278153".to_string(),
            balance: 1_000_000.0,
            frozen: 12_345.0,
        }],
        ..ek_ui::state::TradeSnap::default()
    });
    let harness = harness_for(&shared);
    assert_eq!(harness.get_all_by_label("278153").count(), 1, "账户列");
    assert!(
        harness.query_by_label_contains("1000000").is_some(),
        "权益(0.3.3 起资金表走 format::price:整数不带 .00)"
    );
    assert!(harness.query_by_label_contains("12345").is_some(), "冻结");
    assert!(
        harness.query_by_label_contains("987655").is_some(),
        "可用 = balance-frozen"
    );
    // 空帧(0.4.1 六期 BD-UI-59):表头恒在、提示词不得有(旧口径画「(无资金:等网关 eAccount.)」)。
    let shared2 = Arc::new(UiShared::new());
    let h2 = harness_for(&shared2);
    assert!(
        h2.query_by_label("权益").is_some(),
        "空帧资金格表头必须在(0.8.5 起「余额」改名「权益」)"
    );
    assert_eq!(
        h2.query_all_by_label_contains("等网关 eAccount").count(),
        0,
        "空态提示词已退役(BD-UI-59)"
    );
}

/// v4 菜单 → 弹窗开合(BD-UI-31 R1:一键直达 —— 菜单钮即入口,单击直接弹窗,
/// 不再有下拉层;运维/网关/查询合约三入口走 UI 面,非直改状态)。
#[test]
fn s17_menu_opens_windows() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = Arc::new(UiShared::new());
    feed_rows(&shared, demo_rows());
    let mut harness = harness_for(&shared);

    // 默认全关。
    assert!(!shared.ops_window_open());
    assert!(!shared.accounts_window_open());
    assert!(!shared.contracts_window_open());

    // 运维钮单击 → 窗开(窗内容面证)。
    harness
        .get_by_label(ek_ui::render::MENU_OPS)
        .click_accesskit();
    harness.run();
    assert!(shared.ops_window_open());
    // 0.2.10(BD-UI-38):「流控查询」钮随 sim 退场撤除——窗开证据改由
    // 运维表固定表头行证(demo_rows 快照在场)。
    assert!(harness.query_by_label_contains("插件").is_some());

    // 账户钮单击 → 账户面板(0.2.15 多账号面:旧「网关」窗退役收纳于此)。
    harness
        .get_by_label(ek_ui::render::MENU_ACCOUNTS)
        .click_accesskit();
    harness.run();
    assert!(shared.accounts_window_open());
    assert!(
        harness
            .query_by_label(ek_ui::render::BTN_ACCOUNT_ADD)
            .is_some(),
        "账户面板表单在场"
    );

    // 查询合约钮单击 → 查询合约窗。
    harness
        .get_by_label(ek_ui::render::MENU_CONTRACTS)
        .click_accesskit();
    harness.run();
    assert!(shared.contracts_window_open());
    assert!(harness.query_by_label_contains("代码或交易所").is_some());
}

/// v4 查询合约窗(Python ContractManager 等价;0.8.5 起**行点 = 勾选**:勾选框列
/// 按用户裁定撤除,行内任一格单击翻转订阅勾选,同一份存储喂给「订阅勾选集」钮);
/// 查询串过滤;空勾选不入列 + 日志。
#[test]
fn s18_contracts_window_query_select_subscribe() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = Arc::new(UiShared::new());
    feed_rows(&shared, demo_rows());
    // 订阅路由前置:先指定行情源(未指定 = 订阅不发,规划 §5.C)。
    let gw = seed_md_source(&shared, "9999", "278153");
    shared.set_contracts_window_open(true);
    shared.update_contract(&contract(
        ek_data::constant::Exchange::SHFE,
        "rb2605",
        "螺纹钢2605",
    ));
    shared.update_contract(&contract(
        ek_data::constant::Exchange::DCE,
        "a2709",
        "黄玉米2709",
    ));

    let mut harness = harness_for(&shared);
    // 0.8.5:勾选框列已删,en_symbol 标签格不复存在 —— 显式判负(回流 = 倒退)。
    assert!(
        harness.query_by_label("DCE.a2709").is_none()
            && harness.query_by_label("SHFE.rb2605").is_none(),
        "合约表的 en_symbol 勾选框标签必须不存在(0.8.5 撤列;若在 = 勾选框回来了)"
    );

    // 行点(名称格)= 勾选 → 订阅选中 → CtpSubscribe 裸代码入列。
    harness.get_by_label("螺纹钢2605").click_accesskit();
    harness.run();
    assert_eq!(shared.selected_contracts(), vec!["SHFE.rb2605".to_string()]);
    harness
        .get_by_label(ek_ui::render::BTN_SUBSCRIBE_SELECTED)
        .click_accesskit();
    harness.run();
    let cmds = shared.drain_cmds();
    assert_eq!(cmds.len(), 1);
    match &cmds[0] {
        UiCmd::CtpSubscribe { gateway, symbols } => {
            assert_eq!(gateway, &gw, "订阅一律路由到行情元账号");
            assert_eq!(symbols, &vec!["rb2605".to_string()], "en_symbol → 裸代码");
        }
        other => panic!("expected CtpSubscribe, got {other:?}"),
    }

    // 查询串过滤:DCE → 只剩 DCE 行(行级地名格 = 名称,不再有 en_symbol 标签)。
    shared.set_contract_query("DCE");
    harness.run();
    assert!(harness.query_by_label("黄玉米2709").is_some());
    assert!(
        harness.query_by_label("螺纹钢2605").is_none(),
        "过滤后不上屏"
    );

    // 取消勾选 → 空订阅不入列 + 日志口径(双击不在语义面:同一行再点一次即翻回)。
    shared.set_contract_query(String::new());
    harness.run();
    harness.get_by_label("螺纹钢2605").click_accesskit(); // 行点翻回取消
    harness.run();
    assert!(shared.selected_contracts().is_empty());
    harness
        .get_by_label(ek_ui::render::BTN_SUBSCRIBE_SELECTED)
        .click_accesskit();
    harness.run();
    assert!(shared.drain_cmds().is_empty(), "空勾选不得入列");
    assert!(
        shared
            .logs_snapshot()
            .0
            .iter()
            .any(|l| l.contains("未勾选任何合约")),
        "空勾选日志口径缺位"
    );
}

/// v4 全撤钮:活动委托逐个走撤单 ask(界面侧扇出;终态行不发)。
#[test]
fn s19_cancel_all_fanout() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = Arc::new(UiShared::new());
    feed_rows(&shared, demo_rows());
    let mk = |id: &str, status: ek_data::constant::Status| ek_data::order::OrderData {
        gateway_name: "ctp".to_string(),
        symbol: "rb2605".to_string(),
        exchange: ek_data::constant::Exchange::SHFE,
        orderid: id.to_string(),
        status,
        ..ek_data::order::OrderData::default()
    };
    shared.seed_trade_snap(ek_ui::state::TradeSnap {
        orders: vec![
            mk("A1", ek_data::constant::Status::NOTTRADED),
            mk("A2", ek_data::constant::Status::PARTTRADED),
            mk("T1", ek_data::constant::Status::ALLTRADED),
            mk("T2", ek_data::constant::Status::CANCELLED),
        ],
        ..ek_ui::state::TradeSnap::default()
    });
    let mut harness = harness_for(&shared);
    harness
        .get_by_label(ek_ui::render::BTN_CANCEL_ALL)
        .click_accesskit();
    harness.run();
    let cmds = shared.drain_cmds();
    assert_eq!(cmds.len(), 2, "只活动委托扇出");
    let ids: Vec<String> = cmds
        .iter()
        .map(|c| match c {
            ek_ui::state::UiCmd::CancelOrder { orderid, .. } => orderid.clone(),
            other => panic!("expected CancelOrder, got {other:?}"),
        })
        .collect();
    assert_eq!(ids, vec!["A1".to_string(), "A2".to_string()]);
    assert!(
        shared
            .logs_snapshot()
            .0
            .iter()
            .any(|l| l.contains("全撤入列 2 笔")),
        "全撤日志留痕"
    );
}

/// BD-UI-26 CJK 渲染专项钉:乱码根因(epaint 缺省字体组无 CJK 字形)。
/// 判据三层:① 候选字体必须装进样式表(每个文字样式都点名 CJK 登记名);
/// ② 全汉字密集页的中文行必须在语义树里在场;③ 这一帧的绘制指令里这串中文必须
/// 排出真实宽度(豆腐块/空 galley 宽度会掉到几十)。原来是一条入 baseline 的快照,
/// 看图这条已撤除(HANDOVER §17)。
#[test]
fn s16_cjk_font_is_installed_and_lays_out() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = Arc::new(UiShared::new());
    feed_snapshot(
        &shared,
        vec![("svctl".to_string(), vec!["svctl.list".to_string()])],
    );
    feed_rows(
        &shared,
        vec![ek_station::wire::PlugRow {
            name: "观测".to_string(),
            version: "0.1.0".to_string(),
            state: "运行中".to_string(),
            deps: vec!["依赖甲".to_string()],
            spilled: 0,
            panics: 0,
            pending: 0,
            peak: 0,
            soft_cap: ek_core::plugin::MAILBOX_SOFT_CAP,
        }],
    );
    shared.set_ops_window_open(true);
    shared.set_bottomright_tab(ek_ui::state::BottomRightTab::Logs);
    shared.update_tick(&tick(
        ek_data::constant::Exchange::SHFE,
        "rb2605",
        "螺纹钢2605",
        101.0,
        1.25,
    ));
    shared.log_line(
        "[INFO][字体] 观测台插件状态版本依赖行情委托成交持仓资金冻结订阅授权密码查询合约运维撤单",
    );
    let mut harness = harness_for(&shared);
    let hit = ek_ui::fonts::apply_cjk_fonts(&harness.ctx);
    assert!(
        hit.is_some(),
        "验收环境必须有 CJK 候选字体(乱码环境不得跑本钉)"
    );
    harness.run();
    // 字体装没装进样式表:CJK 登记名必须挂在 Proportional 与 Monospace 两族上
    // (`apply_cjk_fonts` 的口径 = 追加到两族末尾,拉丁仍走缺省字体)。
    let families = harness.ctx.fonts(|f| f.definitions().families.clone());
    for family in [egui::FontFamily::Proportional, egui::FontFamily::Monospace] {
        let list = families
            .get(&family)
            .unwrap_or_else(|| panic!("{family} 族必须在字体表里"))
            .clone();
        assert!(
            list.iter().any(|n| n == ek_ui::fonts::CJK_FONT_NAME),
            "{family} 族必须挂上 CJK 登记名「{}」,实测 {list:?}",
            ek_ui::fonts::CJK_FONT_NAME
        );
    }
    // 中文串在语义树里在场(内容钉)。
    assert!(
        harness
            .query_by_label_contains("查询合约运维撤单")
            .is_some(),
        "日志表里的长中文行必须在语义树里"
    );
    // 排版宽度钉:这一帧真的把这串中文排出来了(30 多个全角字 @16px ≈ 480 pt),
    // 豆腐块/空 galley 会当场把宽度掉到几十。原来这条靠一张 CJK 快照看图 —— 已撤除。
    let probe = texts_containing(&shapes_of(&harness), "查询合约运维撤单");
    let widths: Vec<f32> = probe.iter().map(|(_, r, _)| r.width()).collect();
    assert!(
        widths.iter().any(|w| *w > 300.0),
        "中文行必须排出真实宽度(>300 pt),实测 {widths:?}"
    );
}

/// 订阅入口一钉:下单面板代码框回车 = CtpSubscribe 入列(Python TradingWidget
/// returnPressed → set_en_symbol 等价;BD-UI-27 订阅两入口之一)。
/// 代码框 = 全 UI 首个 TextInput(下单面板先画;价格/数量框在后,ComboBox 非 TextInput)。
#[test]
fn s20_enter_subscribes_symbol() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = Arc::new(UiShared::new());
    feed_rows(&shared, demo_rows());
    // 订阅路由前置:先指定行情源(未指定 = 订阅不发,规划 §5.C)。
    let gw = seed_md_source(&shared, "9999", "278153");
    let mut harness = harness_for(&shared);
    harness.run();
    // Node 借用 harness 树:先取 accesskit id 再驱动事件(借用检查)。
    let target = {
        let sym = harness
            .get_all_by_role(egui::accesskit::Role::TextInput)
            .next()
            .expect("代码框 TextInput 在场");
        sym.accesskit_node().id()
    };
    harness.event(egui::Event::AccessKitActionRequest(
        egui::accesskit::ActionRequest {
            action: egui::accesskit::Action::Focus,
            target,
            data: None,
        },
    ));
    harness.step();
    harness.event(egui::Event::Text("rb2605".to_string()));
    harness.step();
    harness.key_press(egui::Key::Enter);
    harness.step();
    let cmds = shared.drain_cmds();
    assert_eq!(cmds.len(), 1, "回车订阅恰一次入列: {cmds:?}");
    match &cmds[0] {
        ek_ui::state::UiCmd::CtpSubscribe { gateway, symbols } => {
            assert_eq!(gateway, &gw, "订阅一律路由到行情元账号");
            assert_eq!(symbols, &vec!["rb2605".to_string()], "裸代码订阅");
        }
        other => panic!("expected CtpSubscribe, got {other:?}"),
    }
    assert!(
        shared
            .logs_snapshot()
            .0
            .iter()
            .any(|l| l.contains("代码回车订阅")),
        "回车订阅日志留痕"
    );
    // 守卫:空代码回车不入列。
    shared.set_order_form(ek_ui::state::OrderForm::default());
    harness.run();
    harness.key_press(egui::Key::Enter);
    harness.step();
    assert!(shared.drain_cmds().is_empty(), "空代码回车不得入列");
}

/// BD-UI-28④ 表列逐值补全钉:满表(委托 17 列 / 成交 12 列 / 持仓 16 列)的**列名**
/// 与**行内容**都必须出现在语义树里 —— 列面退化(少列、Grid sizing 叠行 BD-UI-27)
/// 当场红。原来这条靠一张整面板 baseline 快照 diff,看图这条已撤除(HANDOVER §17)。
#[test]
fn s21_full_tables_columns_and_rows() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = Arc::new(UiShared::new());
    feed_rows(&shared, demo_rows());
    shared.update_tick(&tick(
        ek_data::constant::Exchange::SHFE,
        "rb2605",
        "螺纹钢2605",
        101.0,
        1.25,
    ));
    shared.seed_trade_snap(ek_ui::state::TradeSnap {
        orders: vec![
            ek_data::order::OrderData {
                gateway_name: "ctp".to_string(),
                symbol: "rb2605".to_string(),
                exchange: ek_data::constant::Exchange::SHFE,
                orderid: "CTP_7701".to_string(),
                order_type: ek_data::constant::OrderType::LIMIT,
                direction: Some(ek_data::constant::Direction::LONG),
                offset: ek_data::constant::Offset::OPEN,
                price: 101.0,
                volume: 2.0,
                traded: 1.0,
                traded_price: 101.0,
                status: ek_data::constant::Status::PARTTRADED,
                status_msg: "部分成交".to_string(),
                name: "螺纹钢2605".to_string(),
                reference: "LOCAL-1".to_string(),
                datetime: Some(36_000_000_000_000),
            },
            ek_data::order::OrderData {
                gateway_name: "ctp".to_string(),
                symbol: "rb2605".to_string(),
                exchange: ek_data::constant::Exchange::SHFE,
                orderid: "CTP_7702".to_string(),
                order_type: ek_data::constant::OrderType::LIMIT,
                direction: Some(ek_data::constant::Direction::SHORT),
                offset: ek_data::constant::Offset::CLOSE,
                price: 102.0,
                volume: 1.0,
                traded: 0.0,
                traded_price: 0.0,
                status: ek_data::constant::Status::REJECTED,
                status_msg: "资金不足".to_string(),
                name: "螺纹钢2605".to_string(),
                datetime: Some(36_000_000_000_000),
                ..ek_data::order::OrderData::default()
            },
        ],
        trades: vec![ek_data::trade::TradeData {
            gateway_name: "ctp".to_string(),
            symbol: "rb2605".to_string(),
            exchange: ek_data::constant::Exchange::SHFE,
            orderid: "CTP_7701".to_string(),
            tradeid: "T-8801".to_string(),
            direction: Some(ek_data::constant::Direction::LONG),
            offset: ek_data::constant::Offset::OPEN,
            price: 101.0,
            volume: 1.0,
            traded_amount: 101.0,
            name: "螺纹钢2605".to_string(),
            datetime: Some(36_000_000_000_000),
            ..ek_data::trade::TradeData::default()
        }],
        positions: vec![ek_data::position::PositionData {
            gateway_name: "ctp".to_string(),
            symbol: "rb2605".to_string(),
            exchange: ek_data::constant::Exchange::SHFE,
            direction: ek_data::constant::Direction::LONG,
            volume: 1.0,
            yd_volume: 0.0,
            can_use_volume: 1.0,
            frozen: 0.0,
            on_road_volume: 0.0,
            market_value: 101.0,
            price: 101.0,
            avg_price: 101.0,
            last_price: 101.0,
            pnl: 0.0,
            profit_rate: 0.0,
            name: "螺纹钢2605".to_string(),
        }],
        accounts: vec![],
    });
    // 宽夹具(BD-UI-55):本钉要读「CTP_7701」(委托表第 14 列)与「T-8801」(成交表
    // 第 10 列)—— 1280 宽时都在横向裁剪外,egui_table 不建构裁剪外的格(见
    // `harness_wide_for`)。
    let mut harness = harness_wide_for(&shared);
    let hit = ek_ui::fonts::apply_cjk_fonts(&harness.ctx); // BD-UI-26 同款闸
    assert!(hit.is_some(), "验收环境必须有 CJK 候选字体");
    harness.run();
    // 三张表都真把行排进语义树(内容钉;原来这里是一张整面板快照,已撤除)。
    for want in [
        "CTP_7701",
        "CTP_7702",
        "T-8801",
        "螺纹钢2605",
        "部分成交",
        "资金不足",
    ] {
        assert!(
            harness.query_all_by_label_contains(want).next().is_some(),
            "整面板三张表里必须有「{want}」这一格"
        );
    }
    // 委托两行 / 成交一行 / 持仓一行:行数就是数据行数,不是画了个空壳。
    // 「CTP_7701」两处 = 委托表那一行 + 成交表那行的『委托号』格(成交挂在委托上);
    // 「CTP_7702」只属于委托表 → 一处,重复 = 表被建构两遍。
    assert_eq!(
        harness.query_all_by_label("CTP_7701").count(),
        2,
        "委托行 CTP_7701 + 成交行的委托号格,共 2 处"
    );
    assert_eq!(
        harness.query_all_by_label("CTP_7702").count(),
        1,
        "委托行 CTP_7702 必须只有一格(重复 = 表重复建构)"
    );
    assert_eq!(
        harness.query_all_by_label("T-8801").count(),
        1,
        "成交表必须正好一行(成交号 T-8801)"
    );
    // 列名逐列在场:三张表共用的列名按「至少几处」钉,专属列名按「至少一处」钉。
    for (col, at_least) in [
        ("委托号", 2),
        ("接口", 3),
        ("代码", 3),
        ("名称", 3),
        ("交易所", 3),
        ("方向", 3),
        ("开平", 3),
        ("价格", 3),
        ("时间", 3),
        ("总量", 1),
        ("已成", 1),
        ("成交均价", 1),
        ("状态", 1),
        ("状态描述", 1),
        ("来源", 1),
        ("成交号", 1),
        ("数量", 1),
        ("成交金额", 1),
        ("成本", 1),
        ("均价", 1),
        ("最新价", 1),
        ("盈亏", 1),
        // 行情 16 列新格与撤改的列(0.8.5):
        ("成交额", 1), // 行情新列
        ("持仓量", 1), // 行情新列
                       // 0.8.5 撤列:「操作/在途/市值/盈亏比」不再出现在任何表头 ——
                       // 它们若回流 = 撤列倒退(显式判负,不再是"至少一处"的正钉)。
    ] {
        let n = harness.query_all_by_label(col).count();
        assert!(
            n >= at_least,
            "列「{col}」必须至少 {at_least} 处,实测 {n} 处"
        );
    }
}

/// s42(BD-UI-40,0.2.26;0.4.1 四期 BD-UI-57 换色板):唯一主题钉。
/// 夹具与 s21 同源(同一套委托/成交/持仓行)—— 同一副内容,判据只落在主题上:
/// ① egui 样式逐字段 == `tokens::visuals()`;② 这一帧的绘制指令里真的出现 BG1 底
/// 与 `border` 整行横线。原来是一条入 baseline 的整面板快照(外加一份已删除的
/// `tests/theme_pixels.rs` 采样),看图这条已撤除(HANDOVER §17)。
#[test]
fn s42_theme_lands_on_style_and_frame() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = Arc::new(UiShared::new());
    feed_rows(&shared, demo_rows());
    shared.seed_trade_snap(ek_ui::state::TradeSnap {
        orders: vec![ek_data::order::OrderData {
            gateway_name: "ctp".to_string(),
            symbol: "rb2605".to_string(),
            exchange: ek_data::constant::Exchange::SHFE,
            orderid: "CTP_7701".to_string(),
            order_type: ek_data::constant::OrderType::LIMIT,
            direction: Some(ek_data::constant::Direction::LONG),
            offset: ek_data::constant::Offset::OPEN,
            price: 101.0,
            volume: 2.0,
            traded: 1.0,
            traded_price: 101.0,
            status: ek_data::constant::Status::PARTTRADED,
            status_msg: "部分成交".to_string(),
            name: "螺纹钢2605".to_string(),
            reference: "LOCAL-1".to_string(),
            datetime: Some(36_000_000_000_000),
        }],
        trades: vec![ek_data::trade::TradeData {
            gateway_name: "ctp".to_string(),
            symbol: "rb2605".to_string(),
            exchange: ek_data::constant::Exchange::SHFE,
            orderid: "CTP_7701".to_string(),
            tradeid: "T-8801".to_string(),
            direction: Some(ek_data::constant::Direction::LONG),
            offset: ek_data::constant::Offset::OPEN,
            price: 101.0,
            volume: 1.0,
            traded_amount: 101.0,
            name: "螺纹钢2605".to_string(),
            datetime: Some(36_000_000_000_000),
            ..ek_data::trade::TradeData::default()
        }],
        positions: vec![ek_data::position::PositionData {
            gateway_name: "ctp".to_string(),
            symbol: "rb2605".to_string(),
            exchange: ek_data::constant::Exchange::SHFE,
            direction: ek_data::constant::Direction::LONG,
            volume: 1.0,
            yd_volume: 0.0,
            can_use_volume: 1.0,
            frozen: 0.0,
            on_road_volume: 0.0,
            market_value: 101.0,
            price: 101.0,
            avg_price: 101.0,
            last_price: 101.0,
            pnl: 0.0,
            profit_rate: 0.0,
            name: "螺纹钢2605".to_string(),
        }],
        accounts: vec![],
    });
    let mut harness = harness_for(&shared);
    let hit = ek_ui::fonts::apply_cjk_fonts(&harness.ctx);
    assert!(hit.is_some(), "验收环境必须有 CJK 候选字体");
    harness.run();
    // ① 主题必须**整套**落在 egui 样式上(逐字段比,不是看一张整面板图)。
    //    夹具与 s21 同源:同一副内容,判据只看主题。
    assert_eq!(
        harness.ctx.style().visuals.clone(),
        ek_ui::tokens::visuals(),
        "shadcn Nova 深色必须整套装进 egui 样式 —— 样式与令牌源不一致"
    );
    // ② 而且这一帧真的用它画了东西:BG1 实心底 + `border` 整行横线都在绘制指令里。
    let shapes = shapes_of(&harness);
    let bg1 = filled_rects(&shapes, ek_ui::tokens::shadcn::BG1);
    assert!(
        bg1.iter().any(|r| r.area() > 1_000.0),
        "整面板必须真画出 BG1(#0A0A0A)底,实测 {bg1:?}"
    );
    let border_lines = hlines(&shapes, ek_ui::tokens::shadcn::BORDER);
    assert!(
        border_lines.iter().any(|(_, x)| x.span() > 200.0),
        "窗框/分隔线必须是 `border`(白 10%)整行横线,实测最长 {:?}",
        border_lines
            .iter()
            .map(|(_, x)| x.span())
            .fold(0.0, f32::max)
    );
}

/// U1 **真实手势**钉。裁定链:0.2.30 裁定 8(BD-UI-46)把五套主题减成一套并删钮,这条钉当时
/// 挡的是「钮删了但画面没换 / 画面换了但钮还挂着」。**0.8.0(BD-UI-61)改判**:深色档重调 +
/// 新增浅色档 + 菜单放一颗两档钮 → 这条**按方案白名单改向**为:
/// ① 菜单里**恰有一颗**主题钮(标签 = 要去的那档);② 原四条菜单钮都还在(不许连带删菜单);
/// ③ 缺省档底色 = 深档 `BG1`(改**引用**令牌,不再写死 `#0A0A0A`);④ 真点一次钮,画面底色
/// 真的换档、再点一次真的换回来(旧钉挡的那类错法照挡);⑤ 落盘标记只由手点立起。
#[test]
fn u1_menu_has_one_theme_button_and_both_looks_land_on_screen() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = Arc::new(UiShared::new());
    feed_rows(&shared, demo_rows());
    let mut harness = harness_for(&shared);
    let hit = ek_ui::fonts::apply_cjk_fonts(&harness.ctx);
    assert!(hit.is_some(), "验收环境必须有 CJK 候选字体");
    harness.run();
    // ① 恰有一颗主题钮(0 = 改判要做的入口没做;>1 = 入口重复,方案只要单点入口)。
    let theme_btn: Vec<_> = harness.query_all_by_label_contains("主题:").collect();
    assert_eq!(
        theme_btn.len(),
        1,
        "菜单里必须恰有一颗「主题:」钮(单点入口),实测 {n} 个节点",
        n = theme_btn.len()
    );
    // ② 菜单本身还在(不许把整条菜单连带删掉)。
    for label in ["运维", "账户", "查询合约", "帮助"] {
        assert!(
            harness.query_all_by_label_contains(label).next().is_some(),
            "菜单钮「{label}」必须还在"
        );
    }
    // ③ 缺省 = 深色(裁定 B:没点过钮 = 现行为零变化),且真的落到画面上。
    assert_eq!(
        harness.ctx.style().visuals.window_fill,
        ek_ui::tokens::PALETTE_DARK.bg1,
        "缺省档(深色)的底色没落到画面上"
    );
    // ④ 真点击切到浅档 → 画面底色真的换档(状态换了画面没换 = 旧 u1 挡的那类错)。
    harness
        .query_by_label_contains("主题:")
        .expect("菜单必须有主题钮")
        .click_accesskit();
    harness.run();
    assert_eq!(
        shared.theme(),
        ek_ui::tokens::Theme::Light,
        "点一下钮状态位必须换档"
    );
    assert_eq!(
        harness.ctx.style().visuals.window_fill,
        ek_ui::tokens::PALETTE_LIGHT.bg1,
        "浅色档的底色没落到画面上(状态换了画面没换)"
    );
    // 再点一次切回深档(两档往返,不是单向)。
    harness
        .query_by_label_contains("主题:")
        .expect("菜单必须有主题钮")
        .click_accesskit();
    harness.run();
    assert_eq!(
        shared.theme(),
        ek_ui::tokens::Theme::Dark,
        "第二下必须切回深色"
    );
    assert_eq!(
        harness.ctx.style().visuals.window_fill,
        ek_ui::tokens::PALETTE_DARK.bg1,
        "切回深色后底色必须复原"
    );
    // ⑤ 落盘标记只由用户手点立起(参考站「只有点击才存 localStorage」的口径)。
    assert!(
        shared.take_theme_persist_due(),
        "用户手点之后必须有落盘请求(命令线程写 ui.theme)"
    );
}

/// s24(0.2.3 回归钉,Immediate 路径守卫,「查询合约窗关不掉」根因面):
/// egui 销毁判据 = 子 viewport 本拍未 used(源码 context.rs「never used this
/// pass」)——show_viewport_immediate 每拍无条件调用 = 每拍 used = OS 窗永不
/// 被销毁(X 点了被重新用起来)。注入 recording renderer(模拟支持多窗的
/// 后端:eframe 桌面同款 set_immediate_viewport_renderer)+ embed=false,
/// 钉三拍:位关不 show / 位开恰 show 一次 / 关闭翻位后不再 show。
/// (Embedded 回退面靠 .open 旗标本就正确——0.2.2 的 21 绿正是被回退掩盖,
/// 此钉补的就是无覆盖的 Immediate 面。)
#[test]
fn s24_contracts_viewport_guard_immediate_path() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    use std::cell::RefCell;
    use std::rc::Rc;

    let seen: Rc<RefCell<Vec<String>>> = Rc::new(RefCell::new(Vec::new()));
    let sink = Rc::clone(&seen);
    egui::Context::set_immediate_viewport_renderer(move |_ctx, vp| {
        // 记录窗标题;cb 必须在一次性临时 Context 里跑(egui 要求 renderer 调
        // cb,而 cb 的 CentralPanel 不能撞 harness 根视口已开的面板纪律——
        // 真实 eframe 是用子窗 raw input 嵌套 run,此处同构简化)。
        sink.borrow_mut()
            .push(vp.builder.title.clone().unwrap_or_default());
        let tmp = egui::Context::default();
        let mut vp = vp;
        let _out = tmp.run(egui::RawInput::default(), |c| {
            (vp.viewport_ui_cb)(c);
        });
    });

    let shared = Arc::new(UiShared::new());

    // 计数走增量口径(kittest build 内部拍数不钉死,钉的是"位关=零 show /
    // 位开=有 show / 翻负=零 show"的守卫语义)。
    // 拍 1:状态位关 → 必须零 show(0.2.2 病灶:每拍都 show)。
    let n0 = seen.borrow().len();
    let _h0 = Harness::builder().with_size([1280.0, 860.0]).build(|ctx| {
        ctx.set_embed_viewports(false); // 模拟支持多窗的后端
        render_body(ctx, &shared);
    });
    assert_eq!(
        seen.borrow().len(),
        n0,
        "状态位关却调了 show_viewport_immediate = 窗永不被 GC(关不掉根因)"
    );

    // 拍 2:状态位开 → 必须有 show。
    shared.set_contracts_window_open(true);
    let n1 = seen.borrow().len();
    let _h1 = Harness::builder().with_size([1280.0, 860.0]).build(|ctx| {
        ctx.set_embed_viewports(false);
        render_body(ctx, &shared);
    });
    assert!(seen.borrow().len() > n1, "状态位开必须 show(否则窗出不来)");
    assert!(
        seen.borrow()[n1..].iter().all(|t| t == "查询合约窗"),
        "Immediate 面 show 的窗必须是查询合约窗"
    );

    // 拍 3:模拟 OS X 之后(cb 已把位翻负)→ 不得再 show(再 show = 永不销毁)。
    shared.set_contracts_window_open(false);
    let n2 = seen.borrow().len();
    let _h2 = Harness::builder().with_size([1280.0, 860.0]).build(|ctx| {
        ctx.set_embed_viewports(false);
        render_body(ctx, &shared);
    });
    assert_eq!(
        seen.borrow().len(),
        n2,
        "关闭后不得再 show(再 show = 窗永不销毁)"
    );
}

/// s25(BD-UI-34 K线窗两钉):
/// - ESC 快捷关闭(Embedded 回退面可测):开 K线窗 → 按 ESC → 出 kline 列表
///   (Immediate 面同构:body 返回 true → closed → close_kline)。
/// - 默认最大化(Immediate 面 builder 钉):recording renderer 捕获
///   builder.maximized = Some(true)(OS 窗属性,回退面无此概念不测)。
#[test]
fn s25_kline_esc_close_and_maximized() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = Arc::new(UiShared::new());
    feed_rows(&shared, demo_rows());
    feed_market_frame(&shared, 2, 4);
    shared.open_kline("rb2605");
    let mut harness = harness_for(&shared);
    harness.run();
    assert!(shared.kline_symbols().contains(&"rb2605".to_string()));
    harness.input_mut().events.push(egui::Event::Key {
        key: egui::Key::Escape,
        physical_key: None,
        pressed: true,
        repeat: false,
        modifiers: egui::Modifiers::NONE,
    });
    harness.run();
    assert!(
        shared.kline_symbols().is_empty(),
        "ESC 应关闭 K线窗(Embedded 面;Immediate 面同构由 body 返回 true 走同一 close_kline)"
    );

    use std::cell::RefCell;
    use std::rc::Rc;
    type Seen = Rc<RefCell<Vec<(String, Option<bool>)>>>;
    let seen: Seen = Rc::new(RefCell::new(Vec::new()));
    let sink = Rc::clone(&seen);
    egui::Context::set_immediate_viewport_renderer(move |_ctx, vp| {
        sink.borrow_mut().push((
            vp.builder.title.clone().unwrap_or_default(),
            vp.builder.maximized,
        ));
        let tmp = egui::Context::default();
        let mut vp = vp;
        let _out = tmp.run(egui::RawInput::default(), |c| {
            (vp.viewport_ui_cb)(c);
        });
    });
    let shared2 = Arc::new(UiShared::new());
    shared2.open_kline("rb2605");
    let _h = Harness::builder().with_size([1280.0, 860.0]).build(|ctx| {
        ctx.set_embed_viewports(false);
        render_body(ctx, &shared2);
    });
    let hits: Vec<(String, Option<bool>)> = seen
        .borrow()
        .iter()
        .filter(|(t, _)| t.contains("K线"))
        .cloned()
        .collect();
    assert!(!hits.is_empty(), "Immediate 面 K线窗必须 show");
    assert!(
        hits.iter().all(|(_, m)| *m == Some(true)),
        "K线窗 builder 必须默认最大化(BD-UI-34 用户裁定)"
    );
}

/// s26(BD-UI-34 空表口径,0.2.6 修;0.4.1 六期 BD-UI-59 重钉):空态不得缩格——
/// 委托/成交/持仓三表在零数据时**表头必须在**(旧版提前 return 把整格缩成一行字,
/// 用户实看报「未成交里表格缩得很小」)。
/// 六期起另一半反过来:那一行「(无数据)」提示**撤除**,表体就是空的(用户裁定)。
#[test]
fn s26_empty_tables_keep_headers() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = Arc::new(UiShared::new());
    let mut harness = harness_for(&shared);
    harness.run();
    for probe in ["成交号", "昨仓", "状态描述", "委托号"] {
        assert!(
            harness.query_all_by_label_contains(probe).count() >= 1,
            "空态结构钉:{probe} 表头必须存在"
        );
    }
    for gone in [
        "(无委托:等网关 send_order)",
        "(无未成交)",
        "(无成交)",
        "(无持仓)",
        "(无资金:等网关 eAccount.)",
        "(无日志)",
        "(无合约:先连接 CTP,合约随 eContract. 自动回流)",
        "(等待该所 eTick 订阅)",
    ] {
        assert_eq!(
            harness.query_all_by_label_contains(gone).count(),
            0,
            "空态提示词已退役(BD-UI-59):{gone} 不许还在屏上"
        );
    }
}

/// s27(BD-UI-35 缝隙实证钉):滚轮下滚委托表后,① 表头不许被掀走、② 表头带必须还
/// 盖住体表最宽一行、③ 真被画出来的行文字不许从带上方露出(裁剪后为空的行 = 没画,
/// 不算露出)。根因 = ScrollArea 内容裁剪 = inner_rect 外扩 clip_rect_margin(3px),
/// 旧覆盖带从 inner_rect 顶起画 → 滚动行从带上方 3px 余量露出。修 = 带向上/左右扩该余量。
/// 判据全部取「本帧绘制指令 + 裁剪矩形 + 语义树」,不再出快照、不再扫像素。
#[test]
fn s27_scrolled_orders_no_peek_above_header() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = Arc::new(UiShared::new());
    feed_rows(&shared, demo_rows());
    let orders: Vec<ek_data::order::OrderData> = (0..12)
        .map(|i| ek_data::order::OrderData {
            gateway_name: "ctp".to_string(),
            symbol: format!("rb{i}"),
            exchange: ek_data::constant::Exchange::SHFE,
            orderid: format!("SCROLL_{i}"),
            order_type: ek_data::constant::OrderType::LIMIT,
            direction: Some(ek_data::constant::Direction::LONG),
            offset: ek_data::constant::Offset::OPEN,
            price: 100.0 + i as f64,
            volume: 1.0,
            traded: 0.0,
            traded_price: 0.0,
            status: ek_data::constant::Status::SUBMITTING,
            status_msg: String::new(),
            name: String::new(),
            reference: String::new(),
            datetime: Some(36_000_000_000_000),
        })
        .collect();
    shared.seed_trade_snap(ek_ui::state::TradeSnap {
        orders,
        ..Default::default()
    });
    let mut harness = harness_for(&shared);
    let hit = ek_ui::fonts::apply_cjk_fonts(&harness.ctx); // BD-UI-26:快照与实窗同字体面
    assert!(hit.is_some(), "验收环境必须有 CJK 候选字体(s16 同款闸)");
    harness.run();
    let head_before = harness
        .query_by_label("状态描述")
        .expect("委托表必须有「状态描述」表头")
        .rect();
    // 指针移到委托表体中央 → 滚轮下滚 150px(负 delta = 内容上移)。
    harness
        .input_mut()
        .events
        .push(egui::Event::PointerMoved(egui::pos2(500.0, 450.0)));
    harness.input_mut().events.push(egui::Event::MouseWheel {
        unit: egui::MouseWheelUnit::Point,
        delta: egui::vec2(0.0, -150.0),
        modifiers: egui::Modifiers::NONE,
    });
    harness.run();
    // ① 表头不许被滚动掀走(固定表头钉)。
    let header = harness
        .query_by_label("状态描述")
        .expect("委托表必须有「状态描述」表头")
        .rect();
    assert!(
        (header.min.y - head_before.min.y).abs() < 0.5,
        "滚动后表头必须还在原处(前 {:.1} → 后 {:.1})",
        head_before.min.y,
        header.min.y
    );
    // ② 表头带必须还在,且盖到体表最宽一行(缺口 ≤ 90 px,同 s69 口径)。
    let band: Vec<egui::Rect> = filled_rects(&shapes_of(&harness), ek_ui::tokens::shadcn::BG4)
        .into_iter()
        .filter(|r| r.width() > 300.0 && (r.min.y - header.min.y).abs() < 40.0)
        .collect();
    assert!(
        !band.is_empty(),
        "滚动后表头带必须还画着(表头 y={:.1})",
        header.min.y
    );
    let band_right = band.iter().map(|r| r.max.x).fold(0.0f32, f32::max);
    // 体表右缘 = 这一帧**真被画出来**(裁剪后非空)的行文字最右缘 —— 与 s69/s70 同一口径。
    // 语义树里的矩形不算数:滚动面之外的行 AccessKit 照样报矩形(实测最右 1584),
    // 那不是这一帧的画面。
    let body_right = clipped_shapes_of(&harness)
        .iter()
        .filter_map(|cs| {
            let egui::Shape::Text(t) = &cs.shape else {
                return None;
            };
            if !t.galley.text().contains("SCROLL_") {
                return None;
            }
            let visible = t.visual_bounding_rect().intersect(cs.clip_rect);
            visible.is_positive().then_some(visible.max.x)
        })
        .fold(0.0f32, f32::max);
    assert!(
        band_right + 90.0 >= body_right,
        "表头带盖住体表最宽一行的缺口必须 ≤ 90 px(带右 {band_right:.1} / 体表右 {body_right:.1})"
    );
    // ③ 不许有数据行从带上方露出:这一帧真被画出来的行文字(裁剪后非空),
    //    可见部分必须在带底边之下。原来这条靠滚动后的快照 + 闸外像素扫描。
    let band_bottom = band.iter().map(|r| r.max.y).fold(0.0f32, f32::max);
    for cs in clipped_shapes_of(&harness) {
        let egui::Shape::Text(t) = &cs.shape else {
            continue;
        };
        if !t.galley.text().contains("SCROLL_") {
            continue;
        }
        let visible = t.visual_bounding_rect().intersect(cs.clip_rect);
        if !visible.is_positive() {
            continue; // 被裁掉了 = 这一帧没画出来
        }
        assert!(
            visible.min.y >= band_bottom - 1.0,
            "数据行「{}」从表头带上方露出(带底 {:.1},露出顶 {:.1})",
            t.galley.text(),
            band_bottom,
            visible.min.y
        );
    }
}

/// 账户面板守卫(多账号面,规划 §5.B / D3):
/// ① 元账号连接后锁定(有账户在线 = 切换被拒且口径句上屏);
/// ② 移除守卫(该账户有活跃委托 = 该行不给移除钮,只给提示);
/// ③ 撤干净后守卫解除。
#[test]
fn s28_account_md_lock_and_remove_guard() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = Arc::new(UiShared::new());
    feed_rows(&shared, demo_rows());
    let gw1 = seed_md_source(&shared, "9999", "278153");
    let row2 = ek_ui::state::AccountRow::derive(&ek_ui::state::CtpForm {
        broker_id: "9999".to_string(),
        td_user: "220380".to_string(),
        ..Default::default()
    })
    .expect("派生注册名");
    let gw2 = row2.gateway.clone();
    shared.add_account(row2).expect("第二账户");
    assert_eq!(gw2, "ctp_9999_220380", "同 broker 不同账号 = 不同派生名");

    shared.set_accounts_window_open(true);
    let mut harness = harness_for(&shared);
    harness.run();

    // ① 配置阶段:两行都在场,尚未锁定(行 = 网关列派生名单元格)。
    assert!(row_action_exists(&harness, &gw1, "编辑"), "账户行 1");
    assert!(row_action_exists(&harness, &gw2, "编辑"), "账户行 2");
    assert!(!shared.accounts_locked(), "无账户在线 = 可指定行情源");

    // ② 模拟 gw1 上线(svctl 快照回填)→ 元账号锁定(D3:连接后不允许切换)。
    let newly = shared.sync_accounts_connected(&[row("svctl"), row(&gw1), row("dm")]);
    assert_eq!(newly, vec![gw1.clone()], "新上线检测只回本轮新连上的");
    assert!(shared.accounts_locked());
    let err = shared.set_md_source(&gw2).unwrap_err();
    assert!(err.contains("锁定"), "连接后切换必须被拒:{err}");
    harness.run();
    // 0.9.10 口径:锁定不再靠面板底部口径句显形(说明行已删,用户裁定);
    // 界面侧显形 = 源行标记「● 行情源」在场 + 非源行按钮锁着不让点(受理侧显形 = ② 首那条拒)。
    assert!(
        harness
            .query_all_by_label_contains("● 行情源")
            .next()
            .is_some(),
        "元账号行显形「● 行情源」"
    );

    // ③ 移除守卫:gw1 有活跃委托 → 该行不给移除钮,给『先撤 N 笔』出口(规划 §5.B / U10)。
    shared.seed_trade_snap(ek_ui::state::TradeSnap {
        orders: vec![ek_data::order::OrderData {
            gateway_name: gw1.clone(),
            symbol: "rb2605".to_string(),
            exchange: ek_data::constant::Exchange::SHFE,
            orderid: format!("{gw1}.CTP_1_1"),
            status: ek_data::constant::Status::NOTTRADED,
            ..ek_data::order::OrderData::default()
        }],
        ..ek_ui::state::TradeSnap::default()
    });
    harness.run();
    assert!(
        row_action_exists(&harness, &gw1, "先撤 1 笔"),
        "守卫不能只堵门:须给『先撤 N 笔』出口(规划 U10)"
    );
    assert!(
        !row_action_exists(&harness, &gw1, "移除"),
        "有挂单的账户不给移除钮(柜台还在跑单而没人能撤 = 观测黑洞)"
    );

    // ④ 撤干净 → 守卫解除,移除钮回到场(0.9.10 光杆口径:钮不带名字,行带定行)。
    shared.seed_trade_snap(ek_ui::state::TradeSnap::default());
    harness.run();
    assert!(
        row_action_exists(&harness, &gw1, "移除"),
        "守卫解除后该行移除钮回到场"
    );
    assert!(
        harness.query_by_label(&format!("移除 {gw1}")).is_none()
            && harness.query_by_label("移除 278153").is_none(),
        "移除钮不带账户名(0.9.10 光杆口径;寻址恒走派生名,由指令面钉)"
    );
}

// ============ 多账号面新增钉 s29–s31(方案 docs/ek-ma-integration-test-plan.md §I4)============

/// 两账户夹具:元账号(行情源)+ 纯 TD 账号,双双已装配。回带两个派生注册名。
fn two_accounts(shared: &UiShared) -> (String, String) {
    let gw1 = seed_md_source(shared, "9999", "278153");
    let row2 = ek_ui::state::AccountRow::derive(&ek_ui::state::CtpForm {
        broker_id: "9999".to_string(),
        td_user: "220380".to_string(),
        ..Default::default()
    })
    .expect("派生注册名");
    let gw2 = row2.gateway.clone();
    shared.add_account(row2).expect("第二账户");
    let newly = shared.sync_accounts_connected(&[
        row("svctl"),
        row("dm"),
        row("oms"),
        row(&gw1),
        row(&gw2),
    ]);
    assert_eq!(newly.len(), 2, "两账户都该被检出新上线");
    assert!(shared.accounts_locked(), "有账户在线 = 元账号锁定(D3)");
    (gw1, gw2)
}

/// s29 两账户在场:下单钮账户阶梯 + 手动选**非行情源账户**随单入列;
/// 订阅面仍一律路由到行情元账号(下单选谁都不改订阅目标 = 路由定死在界面侧)。
#[test]
fn s29_two_accounts_order_follows_selected_account() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = Arc::new(UiShared::new());
    feed_rows(&shared, demo_rows());
    let (gw1, gw2) = two_accounts(&shared);
    shared.set_contracts_window_open(true);
    shared.update_contract(&contract(
        ek_data::constant::Exchange::SHFE,
        "rb2605",
        "螺纹钢2605",
    ));
    shared.set_order_form(ek_ui::state::OrderForm {
        exchange: "SHFE".to_string(),
        symbol: "rb2605".to_string(),
        direction: ek_data::constant::Direction::LONG,
        offset: ek_data::constant::Offset::OPEN,
        order_type: ek_data::constant::OrderType::LIMIT,
        price: "102.5".to_string(),
        volume: "1".to_string(),
        gateway: gw2.clone(),
        follow_price: false,
        auto_split: true,
    });

    // ① 账户阶梯钉:表单网关位留空 → 取第一个已连接账户(旧「空 → 字面量 ctp」已退役)。
    let ladder = {
        let mut f = shared.order_form();
        f.gateway = String::new();
        shared.set_order_form(f);
        shared.default_gateway()
    };
    assert_eq!(
        ladder.as_deref(),
        Some(gw1.as_str()),
        "阶梯 = 第一个已连接账户"
    );

    let mut harness = harness_for(&shared);
    harness.run();

    // ② 手动选非行情源账户 → 网关位随单入列(纯 TD 账号发得出去单)。
    let mut f = shared.order_form();
    f.gateway = gw2.clone();
    shared.set_order_form(f);
    harness.run();
    let nodes: Vec<_> = harness
        .get_all_by_label(ek_ui::render::BTN_SEND_ORDER)
        .collect();
    // 0.4.1(BD-UI-54):可寻址的「委托」= 下单钮 + 数据区 tab 条那一面(s30 同口径,
    // 点先渲染的下单钮)。
    assert_eq!(nodes.len(), 2, "委托钮 + 委托 tab");
    nodes[0].click_accesskit();
    harness.run();
    let cmds = shared.drain_cmds();
    assert_eq!(cmds.len(), 1, "下单一条入列: {cmds:?}");
    match &cmds[0] {
        UiCmd::SendOrder { req, gateway, .. } => {
            assert_eq!(gateway, &gw2, "下单随所选账户(非行情源也发得出去)");
            assert_eq!(req.symbol, "rb2605");
            assert_eq!(req.price, 102.5);
        }
        other => panic!("expected SendOrder, got {other:?}"),
    }

    // ③ 订阅面不因下单所选账户而改道(元账号是唯一 MD 会话)。
    // 0.8.5:勾选框列删 → 行点(名称格)= 勾选。
    harness.get_by_label("螺纹钢2605").click_accesskit();
    harness.run();
    harness
        .get_by_label(ek_ui::render::BTN_SUBSCRIBE_SELECTED)
        .click_accesskit();
    harness.run();
    let cmds = shared.drain_cmds();
    assert_eq!(cmds.len(), 1, "订阅一条入列: {cmds:?}");
    match &cmds[0] {
        UiCmd::CtpSubscribe { gateway, symbols } => {
            assert_eq!(gateway, &gw1, "订阅一律路由到行情元账号(下单选的是 {gw2})");
            assert_eq!(symbols, &vec!["rb2605".to_string()]);
        }
        other => panic!("expected CtpSubscribe, got {other:?}"),
    }
}

/// s30 全撤扇出随单走:两账户的活跃委托各自带**自己**的网关入列(不再回落单网关);
/// 终态行不发。
#[test]
fn s30_cancel_all_follows_each_orders_gateway() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = Arc::new(UiShared::new());
    feed_rows(&shared, demo_rows());
    let (gw1, gw2) = two_accounts(&shared);
    let mk = |gw: &str, id: &str, status: ek_data::constant::Status| ek_data::order::OrderData {
        gateway_name: gw.to_string(),
        symbol: "rb2605".to_string(),
        exchange: ek_data::constant::Exchange::SHFE,
        orderid: id.to_string(),
        status,
        ..ek_data::order::OrderData::default()
    };
    shared.seed_trade_snap(ek_ui::state::TradeSnap {
        orders: vec![
            mk(&gw1, "A1", ek_data::constant::Status::NOTTRADED),
            mk(&gw1, "A2", ek_data::constant::Status::PARTTRADED),
            mk(&gw2, "B1", ek_data::constant::Status::NOTTRADED),
            mk(&gw2, "B2", ek_data::constant::Status::PARTTRADED),
            mk(&gw1, "T1", ek_data::constant::Status::ALLTRADED),
            mk(&gw2, "T2", ek_data::constant::Status::CANCELLED),
        ],
        ..ek_ui::state::TradeSnap::default()
    });
    let mut harness = harness_for(&shared);
    harness.run();
    harness
        .get_by_label(ek_ui::render::BTN_CANCEL_ALL)
        .click_accesskit();
    harness.run();
    let cmds = shared.drain_cmds();
    assert_eq!(cmds.len(), 4, "只活动委托扇出(终态不发): {cmds:?}");
    let pairs: Vec<(String, String)> = cmds
        .iter()
        .map(|c| match c {
            UiCmd::CancelOrder { orderid, gateway } => (orderid.clone(), gateway.clone()),
            other => panic!("expected CancelOrder, got {other:?}"),
        })
        .collect();
    let to_gw1 = pairs.iter().filter(|(_, g)| g == &gw1).count();
    let to_gw2 = pairs.iter().filter(|(_, g)| g == &gw2).count();
    assert_eq!(to_gw1, 2, "元账号的两笔撤单目标 = 元账号");
    assert_eq!(to_gw2, 2, "纯 TD 账号的两笔撤单目标 = 它自己(撤单随单走)");
    assert!(
        pairs.iter().all(|(id, g)| {
            let own = if id.starts_with('A') { &gw1 } else { &gw2 };
            g == own
        }),
        "逐笔核对:撤单 ask 目标必须等于该单自己的网关:{pairs:?}"
    );
    assert!(
        shared
            .logs_snapshot()
            .0
            .iter()
            .any(|l| l.contains("全撤入列 4 笔")),
        "全撤日志留痕"
    );
}

/// s31 移除在场账户的解锁路径:摘掉行情源账户 → 源位清空(等重新指定)且订阅集保留;
/// 只要还有账户在线就仍锁(D3 不因摘源而松动);全部摘除后重新添加的账户自动定源。
#[test]
fn s31_remove_connected_account_unlocks_md_source() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = Arc::new(UiShared::new());
    feed_rows(&shared, demo_rows());
    let (gw1, gw2) = two_accounts(&shared);
    shared.note_subscriptions(&["rb2605".to_string()]);
    shared.set_accounts_window_open(true);
    let mut harness = harness_for(&shared);
    harness.run();

    // ① 二次确认摘除元账号(无挂单 → 该行移除钮在场;首点翻「确认移除?」)。
    // 0.9.10 光杆口径:钮不带名,行带定行;寻址仍是派生名。
    click_row_action(&mut harness, &gw1, "移除");
    assert_eq!(
        shared.pending_confirm().as_deref(),
        Some(gw1.as_str()),
        "首点 = 待二次确认(内部仍按派生名记槽)"
    );
    assert!(shared.drain_cmds().is_empty(), "armed 不入列");
    click_row_action(&mut harness, &gw1, "确认移除?");
    let cmds = shared.drain_cmds();
    assert!(
        cmds.iter()
            .any(|c| matches!(c, UiCmd::Remove { name } if name == &gw1)),
        "摘除走 svctl.remove: {cmds:?}"
    );
    assert_eq!(shared.accounts().len(), 1, "清册只剩纯 TD 账号");
    assert!(
        shared.md_source().is_empty(),
        "元账号被摘 → 源位清空(等重新指定)"
    );
    assert_eq!(
        shared.subscriptions(),
        vec!["rb2605".to_string()],
        "订阅集保留(规划 §5.C)"
    );

    // ② 仍锁:纯 TD 账号在线就不允许切换(D3);摘源不等于解锁。
    // (0.9.10:面板底部口径句已删,锁定显形 = 受理处拒 + 日志,行为钉在 ② 首两句。)
    let err = shared.set_md_source(&gw2).unwrap_err();
    assert!(err.contains("锁定"), "有账户在线仍须拒:{err}");
    harness.run();

    // ③ 全摘 → 解锁;重新保存的账户自动定源(§5.C 保存即定源)。
    click_row_action(&mut harness, &gw2, "移除");
    click_row_action(&mut harness, &gw2, "确认移除?");
    let _ = shared.drain_cmds();
    assert!(shared.accounts().is_empty(), "清册空");
    assert!(!shared.accounts_locked(), "无账户在线 = 解锁");
    let row3 = ek_ui::state::AccountRow::derive(&ek_ui::state::CtpForm {
        broker_id: "9999".to_string(),
        td_user: "220380".to_string(),
        ..Default::default()
    })
    .expect("派生注册名");
    assert_eq!(row3.gateway, gw2, "重加同名账户 = 同一派生名");
    // 走真实界面路径(『添加账户』开弹窗 → 弹窗『保存』),不走 state 直写
    // (自动定源在保存路径里)。
    add_via_dialog(
        &mut harness,
        &shared,
        acct_form(
            "9999",
            "220380",
            "tcp://182.254.243.31:30001",
            "tcp://182.254.243.31:30011",
        ),
    );
    let cmds = shared.drain_cmds();
    assert!(
        cmds.is_empty(),
        "重加 = 只写清册(0.2.18 四态:『保存』不下发装配/凭据两令): {cmds:?}"
    );
    assert_eq!(
        shared.md_source(),
        gw2,
        "无源 + 无在场账户 → 新添加的账户自动成为元账号(添加即定源)"
    );
    harness.run();
    assert!(row_action_exists(&harness, &gw2, "编辑"), "重加后账户行回到场");
    assert!(
        row_action_exists(&harness, &gw2, "连接"),
        "重加后须点『连接』才装配(四态分离入口在场)"
    );
}

/// s32 无账户 = 无网关可下单(旧「空 → 字面量 ctp」兜底已退役):阶梯回 None、
/// 禁用口径句上屏、点禁用钮不入列;添加账户后同一钮恢复可用且网关位 = 派生名。
#[test]
fn s32_no_account_disables_send_button() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = Arc::new(UiShared::new());
    feed_rows(&shared, demo_rows());
    shared.set_order_form(ek_ui::state::OrderForm {
        exchange: "SHFE".to_string(),
        symbol: "rb2605".to_string(),
        direction: ek_data::constant::Direction::LONG,
        offset: ek_data::constant::Offset::OPEN,
        order_type: ek_data::constant::OrderType::LIMIT,
        price: "102.5".to_string(),
        volume: "1".to_string(),
        gateway: String::new(),
        follow_price: false,
        auto_split: true,
    });
    let mut harness = harness_for(&shared);
    harness.run();

    // ① 无账户:阶梯空 + 口径句上屏。
    assert_eq!(shared.default_gateway(), None, "无账户 = 无默认网关");
    assert!(
        harness.query_by_label_contains("委托钮已禁用").is_some(),
        "禁用口径句在场(不是静默禁用)"
    );

    // ② 点禁用钮不入列(旧兜底若还在,这里会冒出一条 gateway="ctp" 的令)。
    let nodes: Vec<_> = harness
        .get_all_by_label(ek_ui::render::BTN_SEND_ORDER)
        .collect();
    nodes[0].click_accesskit();
    harness.run();
    assert!(shared.drain_cmds().is_empty(), "禁用态点击不得入列");

    // ③ 添加账户后同一钮可用,网关位 = 派生名(不再是字面量 ctp)。
    let gw = seed_md_source(&shared, "9999", "278153");
    // 0.2.18 阶梯(规划 Q4):**只添加了还没装配的账户不进默认** ——
    // 旧阶梯"退到第一个账户"会把未连接的账户选成下单归属,发出去只撞 unknown:gateway。
    assert_eq!(
        shared.default_gateway(),
        None,
        "只添加未装配 = 仍无默认网关(阶梯不再退到第一个账户)"
    );
    harness.run();
    assert!(
        harness.query_by_label_contains("委托钮已禁用").is_some(),
        "未装配账户不得把下单钮点亮"
    );
    mark_assembled(&shared, &gw);
    harness.run();
    assert_eq!(shared.default_gateway().as_deref(), Some(gw.as_str()));
    assert!(
        harness.query_by_label_contains("委托钮已禁用").is_none(),
        "有账户后禁用句撤场"
    );
    let nodes: Vec<_> = harness
        .get_all_by_label(ek_ui::render::BTN_SEND_ORDER)
        .collect();
    nodes[0].click_accesskit();
    harness.run();
    let cmds = shared.drain_cmds();
    assert_eq!(cmds.len(), 1, "有账户后下单入列: {cmds:?}");
    match &cmds[0] {
        UiCmd::SendOrder { gateway, .. } => {
            assert_eq!(gateway, &gw, "网关位取账户派生名(旧字面量 ctp 已退役)");
        }
        other => panic!("expected SendOrder, got {other:?}"),
    }
}

// ============ 账户配置界面核查钉 s33–s38(2026-10-21 界面巡回后补)============
// 口径:这些钉**钉的是现状**,每条都在名字或断言里写明「待修/开放项」——
// 巡回里账户面板的六处问题(docs/ek-ma-business-flow-report.md §10 界面侧)先固化成证据,
// 修哪一条就把对应断言翻成期望口径。

/// 表单夹具(密码用可断言的假值,测试面不碰真凭据)。
fn acct_form(broker: &str, account: &str, td: &str, md: &str) -> ek_ui::state::CtpForm {
    ek_ui::state::CtpForm {
        broker_id: broker.to_string(),
        td_addr: td.to_string(),
        td_user: account.to_string(),
        td_password: "fake-pw-1234".to_string(),
        td_auth_code: "fake-auth".to_string(),
        td_app_id: "fake-app".to_string(),
        md_addr: md.to_string(),
        md_user: String::new(),
        md_password: String::new(),
        symbols: String::new(),
        accept_futures: true,
        accept_options: false,
    }
}

/// 点一次「添加账户」(面板路径,不碰内部 API)。
/// 0.2.18 Commit B 口径:这一下**只开配置弹窗**,不写清册也不下发。
fn click_account_add(harness: &mut Harness<'_>) {
    let nodes: Vec<_> = harness
        .get_all_by_label(ek_ui::render::BTN_ACCOUNT_ADD)
        .collect();
    assert!(!nodes.is_empty(), "『添加账户』钮应在场");
    nodes[0].click_accesskit();
}

/// 0.9.10 光杆钮口径:行内钮**不带账户名**(编辑/移除/连接/断开…,行即对象)。
/// 定行 = 网关列派生名单元格;取钮 = 该行带(rect.y 同带)里指定标签的钮。
/// 行格与钮都走 `query_all`(零命中返回空,多命中取配对 —— 派生名在下单下拉/
/// 监控表里也出现,精确 `query_by_label` 会两中 panic,同带配对天然消歧)。
fn row_action_exists(harness: &Harness<'_>, row_cell: &str, action: &str) -> bool {
    let ys: Vec<f32> = harness
        .query_all(By::new().label(row_cell))
        .map(|n| n.rect().center().y)
        .collect();
    harness
        .query_all(By::new().label(action))
        .any(|n| ys.iter().any(|y| (n.rect().center().y - y).abs() < 14.0))
}

fn click_row_action(harness: &mut Harness<'_>, row_cell: &str, action: &str) {
    let ys: Vec<f32> = harness
        .query_all(By::new().label(row_cell))
        .map(|n| n.rect().center().y)
        .collect();
    assert!(!ys.is_empty(), "面板须有行 {row_cell:?}");
    let nd = harness
        .query_all(By::new().label(action))
        .find(|n| ys.iter().any(|y| (n.rect().center().y - y).abs() < 14.0))
        .unwrap_or_else(|| panic!("行 {row_cell:?} 带里须有 {action:?} 钮"));
    nd.click_accesskit();
    harness.run();
}

/// 配置弹窗里的钮(『保存』/『保存并连接』/『取消』)。
fn click_dialog(harness: &mut Harness<'_>, label: &str) {
    let nodes: Vec<_> = harness.get_all_by_label(label).collect();
    assert!(!nodes.is_empty(), "配置弹窗钮 {label:?} 应在场");
    nodes[0].click_accesskit();
    harness.run();
}

/// Commit B 的完整添加路径:面板『添加账户』开弹窗 → **弹窗打开后**填草稿
/// (`begin_account_edit` 会重置草稿位,开窗前填的会被覆盖)→ 弹窗『保存』写清册。
fn add_via_dialog(harness: &mut Harness<'_>, shared: &UiShared, form: ek_ui::state::CtpForm) {
    click_account_add(harness);
    harness.run();
    assert!(
        shared.account_edit_open(),
        "『添加账户』= 开配置弹窗(Commit B 口径)"
    );
    shared.set_ctp_form(form);
    harness.run();
    click_dialog(harness, "保存");
    assert!(
        !shared.account_edit_open(),
        "『保存』成功 = 弹窗关闭(被拦才留着显形)"
    );
}

/// s33 装配失败后的**期望口径**(0.2.18 修 U3):失败**不回滚清册行**,状态列显
/// 「装配失败:<原因>」红字,行上给『重试』钮 —— 再点『重试』直接下发一条 `Connect` 令,
/// **不需要先移除**(旧口径"必须先移除才能重试"作废)。
/// 生产路径里 `note_connect_sent/result` 由 ui 插件在 `UiCmd::Connect` 出队时回写;
/// 本钉没有宿主,故手工模拟同一条回写(等价性由 plugin.rs 的 Connect 分支保证)。
#[test]
fn s33_failed_start_leaves_row_and_allows_retry() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = Arc::new(UiShared::new());
    feed_rows(&shared, demo_rows());
    shared.set_accounts_window_open(true);
    let mut harness = harness_for(&shared);
    harness.run();
    add_via_dialog(
        &mut harness,
        &shared,
        acct_form(
            "9999",
            "278153",
            "tcp://10.0.0.1:40001",
            "tcp://10.0.0.1:40011",
        ),
    );
    assert!(
        shared.drain_cmds().is_empty(),
        "『保存』只写清册,不下发装配令"
    );
    assert_eq!(shared.accounts().len(), 1, "清册一行");

    // ① 『连接』入口 → 一条 Connect 令 + 状态「装配中」(0.9.10 光杆口径)。
    harness.run();
    click_row_action(&mut harness, "ctp_9999_278153", "连接");
    let cmds = shared.drain_cmds();
    assert_eq!(cmds.len(), 1, "『连接』入列一条令: {cmds:?}");
    assert!(matches!(cmds[0], UiCmd::Connect { .. }));
    shared.note_connect_sent("ctp_9999_278153");
    harness.run();
    assert!(
        harness.query_by_label_contains("装配中").is_some(),
        "装配中须在状态列显形"
    );

    // ② 装配失败(svctl.start 被拒 / 超时 / configure 被拒,插件侧都落到这一形)。
    shared.note_connect_result(
        "ctp_9999_278153",
        Err("svctl.start 被拒:工厂 ctp 不在册".to_string()),
    );
    harness.run();
    let acc = shared
        .account("ctp_9999_278153")
        .expect("期望口径:失败行不回滚,留在清册给重试");
    assert_eq!(acc.stage, ek_ui::state::AccountStage::AssembleFailed);
    assert_eq!(
        acc.fail_note.as_deref(),
        Some("svctl.start 被拒:工厂 ctp 不在册"),
        "失败原因须留档"
    );
    assert!(
        harness.query_by_label_contains("装配失败").is_some(),
        "装配失败必须在界面上显形(旧口径:零显形)"
    );
    assert!(
        row_action_exists(&harness, "ctp_9999_278153", "重试"),
        "失败行须给『重试』入口"
    );

    // ③ 再点『重试』→ 直接入列,不必先移除。
    click_row_action(&mut harness, "ctp_9999_278153", "重试");
    let cmds = shared.drain_cmds();
    assert_eq!(
        cmds.len(),
        1,
        "重试 = 一条 Connect 令(不需先移除): {cmds:?}"
    );
    assert!(matches!(cmds[0], UiCmd::Connect { .. }));
    assert_eq!(shared.accounts().len(), 1, "失败行没被回滚,也没多建行");
}

/// s34 **每账户独立表单**(0.2.18 修 U4):『添加』成功后草稿位的**凭据位一律清空**
/// (账号 / 密码 / 前置),只沿用非凭据字段(broker / AppID / AuthCode,规划 Q20 缓解);
/// 纯 TD 账户的 md 位在**留档**里就清空(旧口径只清下发不清留档 → 编辑页会带一根用不上的行情前置)。
#[test]
fn s34_account_form_is_per_account() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = Arc::new(UiShared::new());
    feed_rows(&shared, demo_rows());
    shared.set_accounts_window_open(true);
    let mut harness = harness_for(&shared);
    harness.run();
    add_via_dialog(
        &mut harness,
        &shared,
        acct_form(
            "9999",
            "278153",
            "tcp://10.0.0.1:40001",
            "tcp://10.0.0.1:40011",
        ),
    );
    let _ = shared.drain_cmds();

    // ① 草稿位:『保存』关弹窗后凭据清空,非凭据沿用。
    let draft = shared.ctp_form();
    assert!(draft.td_user.is_empty(), "期望口径:保存后账号位清空");
    assert!(
        draft.td_password.is_empty(),
        "期望口径:上一家密码不得留在草稿位"
    );
    assert!(draft.td_addr.is_empty(), "期望口径:前置也清空");
    assert_eq!(draft.broker_id, "9999", "非凭据字段沿用(Q20 缓解)");
    assert_eq!(draft.td_app_id, "fake-app", "AppID 沿用");
    assert_eq!(draft.td_auth_code, "fake-auth", "AuthCode 沿用");

    // ② 该账户自己的留档不受清空影响。
    let acc1 = shared.account("ctp_9999_278153").expect("第一账户");
    assert_eq!(
        acc1.form.td_password, "fake-pw-1234",
        "留档保留自己的凭据(清空只作用于草稿位)"
    );

    // ③ 第二账户:必须自己填密码,拿不到上一家的。
    click_account_add(&mut harness);
    harness.run();
    shared.set_ctp_form(ek_ui::state::CtpForm {
        td_user: "220380".to_string(),
        td_addr: "tcp://10.0.0.1:40001".to_string(),
        td_password: "pw-of-220380".to_string(),
        ..shared.ctp_form()
    });
    harness.run();
    click_dialog(&mut harness, "保存");
    let _ = shared.drain_cmds();
    let acc2 = shared.account("ctp_9999_220380").expect("第二账户已入清册");
    assert_eq!(
        acc2.form.td_password, "pw-of-220380",
        "期望口径:新账户只带自己的密码,不继承上一家"
    );
    assert_eq!(
        acc2.form.md_addr, "",
        "期望口径:纯 TD 账户的 md 位在**留档**里就清空(旧缺陷:只清下发不清留档)"
    );
    assert_eq!(
        acc1.form.md_addr, "tcp://10.0.0.1:40011",
        "元账号的 md 留档不被第二账户的单源清空波及"
    );
}

/// s35 编辑态与『取消』(0.2.18 Commit B 修 U6):『编辑 <账户>』开配置弹窗并载入
/// **该账户自己的**留档;『取消』(与关窗同口径)= 放弃未保存且**草稿位凭据一律清空**
/// → 不可能"改一格就建出错配账户"。
/// 编辑模式 broker / 账号只读(规划 Q25)的界面证据 = 只读口径句上屏 + s41 语义树计数
/// (kittest 查询面只按 label 命中,取不到 TextEdit 节点做 disabled 断言 —— 已记入核查)。
#[test]
fn s35_cancel_edit_clears_credentials() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = Arc::new(UiShared::new());
    feed_rows(&shared, demo_rows());
    let gw1 = seed_md_source(&shared, "9999", "278153");
    shared.update_account_form(
        &gw1,
        acct_form(
            "9999",
            "278153",
            "tcp://10.0.0.1:40001",
            "tcp://10.0.0.1:40011",
        ),
    );
    shared.set_accounts_window_open(true);
    let mut harness = harness_for(&shared);
    harness.run();

    // ① 该行『编辑』→ 开配置弹窗(编辑模式),草稿 = 该账户留档(含密码)。
    // (0.9.10 光杆口径:钮不带名,行带定行。)
    click_row_action(&mut harness, &gw1, "编辑");
    assert!(shared.account_edit_open(), "『编辑』= 开配置弹窗(Commit B)");
    assert_eq!(
        shared.editing_account().as_deref(),
        Some(gw1.as_str()),
        "弹窗模式 = 编辑该账户"
    );
    assert_eq!(
        shared.ctp_form().td_password,
        "fake-pw-1234",
        "编辑载入该账户自己的表单(含密码)"
    );
    assert!(
        harness
            .query_by_label_contains("要改这两格请『移除后重加』")
            .is_some(),
        "编辑模式 broker/账号只读的口径句上屏(规划 Q25)"
    );
    assert!(
        harness.query_by_label("保存并连接").is_some(),
        "编辑模式给『保存并连接』出口"
    );

    // ② 『取消』→ 弹窗关 + 草稿位凭据清空。
    click_dialog(&mut harness, "取消");
    assert!(!shared.account_edit_open(), "『取消』= 关弹窗");
    assert!(shared.editing_account().is_none(), "编辑模式解除");
    let draft = shared.ctp_form();
    assert!(
        draft.td_password.is_empty(),
        "期望口径:取消清空凭据(旧口径:原封不动留在共享位)"
    );
    assert!(draft.td_user.is_empty(), "期望口径:账号位也清空");
    assert!(draft.td_addr.is_empty(), "期望口径:前置也清空");
    assert_eq!(draft.broker_id, "9999", "非凭据字段沿用");

    // ③ 此时点『添加账户』→ 开弹窗(草稿空)→ 『保存』被形制校验拦下:
    // 弹窗**不关** + 原因显形 + 不入列(规划 Q26)。
    click_account_add(&mut harness);
    harness.run();
    click_dialog(&mut harness, "保存");
    assert!(shared.account_edit_open(), "被拦不得关弹窗(失败要能就地改)");
    assert_eq!(
        shared.accounts().len(),
        1,
        "清册仍一行(没建出凭据错配的账户)"
    );
    assert!(shared.drain_cmds().is_empty(), "空凭据草稿不得入列");
    assert!(shared.edit_error().is_some(), "拦截原因须在弹窗里显形");
    let (lines, _) = shared.logs_snapshot();
    assert!(
        lines.iter().any(|l| l.contains("保存被拦")),
        "拦截须在日志里显形: {lines:?}"
    );
}

/// s36 前置形制校验(0.2.18 修 U7):旧口径是"`AccountRow::derive` 只校验 broker/账号,
/// **td/md 前置为空也照样建账户并下发两令**"。现在『添加』先过 `CtpForm::validate`:
/// 前置形制不对 → 当场拦下、不入清册、不下发,并在日志里显形。
/// md 前置**允许为空**(纯 TD 账户,单源纪律),td 前置不允许为空。
#[test]
fn s36_empty_front_address_is_rejected() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = Arc::new(UiShared::new());
    feed_rows(&shared, demo_rows());
    shared.set_accounts_window_open(true);
    let mut harness = harness_for(&shared);
    harness.run();
    click_account_add(&mut harness);
    harness.run();
    assert!(shared.account_edit_open(), "『添加账户』= 开配置弹窗");
    // td 前置为空 → 『保存』被拦:不入列、不下发、**弹窗不关**、原因显形(规划 Q26)。
    shared.set_ctp_form(acct_form("9999", "278153", "", ""));
    harness.run();
    click_dialog(&mut harness, "保存");
    assert!(
        shared.drain_cmds().is_empty(),
        "期望口径:前置为空不得下发装配/凭据两令"
    );
    assert!(
        shared.account("ctp_9999_278153").is_none(),
        "期望口径:空前置的账户不入清册(旧口径:原样入库)"
    );
    assert!(shared.account_edit_open(), "被拦不得关弹窗(失败要能就地改)");
    assert!(shared.edit_error().is_some(), "弹窗里须显形拦截原因");
    let (lines, _) = shared.logs_snapshot();
    assert!(
        lines
            .iter()
            .any(|l| l.contains("保存被拦") && l.contains("td 前置")),
        "拦截原因须在日志显形: {lines:?}"
    );

    // 形制不对(缺端口 / 端口非数字)同样被拦 —— 弹窗开着 = 就地改,不必重开重填。
    shared.set_ctp_form(acct_form("9999", "278153", "tcp://10.0.0.1", ""));
    harness.run();
    click_dialog(&mut harness, "保存");
    assert!(shared.account("ctp_9999_278153").is_none(), "缺端口须被拦");
    shared.set_ctp_form(acct_form("9999", "278153", "tcp://10.0.0.1:abc", ""));
    harness.run();
    click_dialog(&mut harness, "保存");
    assert!(
        shared.account("ctp_9999_278153").is_none(),
        "端口非数字须被拦"
    );

    // 合规(td 前置齐、md 前置留空 = 纯 TD)→ 保存成功、弹窗关闭。
    shared.set_ctp_form(acct_form("9999", "278153", "tcp://10.0.0.1:40001", ""));
    harness.run();
    click_dialog(&mut harness, "保存");
    assert!(!shared.account_edit_open(), "保存成功 = 弹窗关闭");
    let acc = shared.account("ctp_9999_278153").expect("合规表单须入清册");
    assert_eq!(acc.form.td_addr, "tcp://10.0.0.1:40001");
    assert!(acc.form.md_addr.is_empty(), "md 前置留空 = 纯 TD 账户,合法");
}

/// s37 账户面板的状态可见性(0.2.18 半修 U5):账户行仍只有**装配口径**
/// (「已装配·登录态未知」/「未装配」/「装配失败:原因」),登录成败、掉线、查询断供
/// 仍无逐行可见位(ek-ctp 无状态口可查 = 界面不谎称);新增的是面板底部一句
/// **状态口径说明**,点名这一缺口(规划 §3.5 缓解)。
/// 状态列两段口径(0.2.19 起):装配位 + 登录态读数,**没有读数时仍写「登录态未知」**。
///
/// 0.2.18 这条钉的是「界面只有在场位、登录成败不可见」(F2 因此在面板上与正常账户同形)。
/// 0.2.19 接上 `{gw}.status` 后口径翻转:缺口从「不可见」变成「本轮还没读到」——
/// 两者在界面上必须长得不一样,否则用户会把「没问到」读成「在线」。
#[test]
fn s37_account_panel_shows_stage_and_login_state() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = Arc::new(UiShared::new());
    feed_rows(&shared, demo_rows());
    let (gw1, gw2) = two_accounts(&shared);
    shared.set_accounts_window_open(true);
    let mut harness = harness_for(&shared);
    harness.run();

    assert!(harness.query_by_label(&gw1).is_some(), "账户行 1");
    assert!(harness.query_by_label(&gw2).is_some(), "账户行 2");
    let seen = harness.query_all_by_label_contains("已装配").count();
    assert_eq!(
        seen, 2,
        "两行账户的状态列各一处「已装配」(0.9.10:面板底部口径句已删,不再有三处)"
    );
    assert!(
        harness.query_by_label_contains("未装配").is_none(),
        "两账户都在场 → 没有『未装配』行"
    );
    // 装配成功但一次状态口都没问到:必须显形「登录态未知」,不得只显示「已装配」。
    assert_eq!(
        harness
            .query_all_by_label_contains("已装配·登录态未知")
            .count(),
        2,
        "两行都必须带「登录态未知」(装配 ≠ 在线,规划 U5 口径)"
    );
    assert_eq!(
        harness.query_all_by_label_contains("已装配·在线").count(),
        0,
        "没有任何登录证据时不得出现「在线」"
    );
    // (0.9.10:面板底部「网关状态口…」口径句随说明行退役;状态来源口径由
    //  本钉的显形断言 + 断开钮守卫钉守住了,见下方与 s51/s54。)
    for needle in ["掉线", "断供"] {
        assert_eq!(
            harness.query_all_by_label_contains(needle).count(),
            0,
            "{needle} 只在真读到该状态时才上屏;两账户现在都是「未知」,一处都不该有"
        );
    }
    // 『断开』钮只给已装配的行(规划裁定 1 + Q21:没有会话可停时不留死钮)。
    // 0.9.10 光杆口径:钮不带名,行带定行;寻址仍用派生名(s47 同源)。
    for gw in [&gw1, &gw2] {
        assert!(
            row_action_exists(&harness, gw, "断开"),
            "已装配账户 {gw} 应有『断开』钮"
        );
        assert!(
            !row_action_exists(&harness, gw, "连接"),
            "已装配且会话未停的行不给『连接』钮"
        );
    }
}

/// s38 摘除账户后的账本残留(界面侧,0.2.18 Commit B 修 U8):清册行消失,但该账户的
/// 委托/持仓行仍在交易监控里(摘除不清账本 = F5 实连复测口径),现在**残留行带
/// 「(已摘除)」标注** —— 旧口径是零标注,用户会把已摘除账户的委托当成在场账户的。
#[test]
fn s38_removed_account_ledger_rows_stay_visible() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = Arc::new(UiShared::new());
    feed_rows(&shared, demo_rows());
    let (gw1, gw2) = two_accounts(&shared);
    shared.seed_trade_snap(ek_ui::state::TradeSnap {
        orders: vec![ek_data::order::OrderData {
            gateway_name: gw2.clone(),
            symbol: "rb2605".to_string(),
            exchange: ek_data::constant::Exchange::SHFE,
            orderid: format!("{gw2}.CTP_9_9"),
            status: ek_data::constant::Status::NOTTRADED,
            ..ek_data::order::OrderData::default()
        }],
        positions: vec![ek_data::position::PositionData {
            gateway_name: gw2.clone(),
            symbol: "rb2605".to_string(),
            exchange: ek_data::constant::Exchange::SHFE,
            volume: 2.0,
            ..ek_data::position::PositionData::default()
        }],
        ..ek_ui::state::TradeSnap::default()
    });
    shared.set_accounts_window_open(true);
    // 宽夹具(BD-UI-55):『已摘除』标注挂在账本行的网关列上(委托表「来源」一路),
    // 1280 宽时那一列在横向裁剪外,egui_table 不建构裁剪外的格(见 `harness_wide_for`)。
    let mut harness = harness_wide_for(&shared);
    harness.run();

    // 有持仓无挂单?这里有挂单 → 守卫先挡(与 s28 同口径),先撤快照再摘。
    assert!(
        !row_action_exists(&harness, &gw2, "移除") && row_action_exists(&harness, &gw2, "先撤 1 笔"),
        "有活跃委托 → 该行不给移除钮,只给『先撤 N 笔』出口(0.9.10 光杆口径)"
    );
    shared.seed_trade_snap(ek_ui::state::TradeSnap {
        positions: vec![ek_data::position::PositionData {
            gateway_name: gw2.clone(),
            symbol: "rb2605".to_string(),
            exchange: ek_data::constant::Exchange::SHFE,
            volume: 2.0,
            ..ek_data::position::PositionData::default()
        }],
        ..ek_ui::state::TradeSnap::default()
    });
    harness.run();
    click_row_action(&mut harness, &gw2, "移除");
    click_row_action(&mut harness, &gw2, "确认移除?");
    harness.run();
    let cmds = shared.drain_cmds();
    assert!(
        cmds.iter()
            .any(|c| matches!(c, UiCmd::Remove { name } if name == &gw2)),
        "摘除令入列: {cmds:?}"
    );
    assert!(shared.account(&gw2).is_none(), "清册行已摘");
    assert!(
        !row_action_exists(&harness, &gw2, "编辑"),
        "账户面板里这个账户整行撤场(行带里再无任何钮)"
    );
    assert!(
        !row_action_exists(&harness, &gw2, "移除"),
        "账户面板里这个账户的移除钮撤场"
    );
    // 摘除后下一拍 eTimer 全量查询照带该账户的账本行(oms 不随摘除清账)——
    // 现状:委托/持仓行原样留着,界面上没有任何「该账户已摘除」的标注。
    shared.seed_trade_snap(ek_ui::state::TradeSnap {
        orders: vec![ek_data::order::OrderData {
            gateway_name: gw2.clone(),
            symbol: "rb2605".to_string(),
            exchange: ek_data::constant::Exchange::SHFE,
            orderid: format!("{gw2}.CTP_9_9"),
            status: ek_data::constant::Status::NOTTRADED,
            ..ek_data::order::OrderData::default()
        }],
        positions: vec![ek_data::position::PositionData {
            gateway_name: gw2.clone(),
            symbol: "rb2605".to_string(),
            exchange: ek_data::constant::Exchange::SHFE,
            volume: 2.0,
            ..ek_data::position::PositionData::default()
        }],
        ..ek_ui::state::TradeSnap::default()
    });
    harness.run();
    let snap = shared.trade_snap();
    assert!(
        snap.orders.iter().any(|o| o.gateway_name == gw2),
        "现状:摘除后委托行仍在账本"
    );
    assert!(
        snap.positions.iter().any(|p| p.gateway_name == gw2),
        "现状:摘除后持仓行仍在账本"
    );
    assert!(
        harness.query_all_by_label_contains("已摘除").count() >= 2,
        "0.2.18 Commit B 修 U8:残留行须带『已摘除』标注(委托行 + 持仓行各一处)——\
         摘除不清账本(F5),但界面必须说清这一行属于谁"
    );
    assert!(shared.account(&gw1).is_some(), "元账号 {gw1} 不受影响");
}

/// s39 账户面板布局钉(语义树):两账户行 + 行情源一览 + 计数含软上限 + 收录列,
/// 一屏之内都在 AccessKit 树里。(原来配一张布局快照,看图这条已撤除。)
#[test]
fn s39_account_panel_layout() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = Arc::new(UiShared::new());
    feed_rows(&shared, demo_rows());
    let (gw1, gw2) = two_accounts(&shared);
    shared.update_account_form(
        &gw1,
        acct_form(
            "9999",
            "278153",
            "tcp://182.254.242.81:30001",
            "tcp://182.254.242.81:30011",
        ),
    );
    shared.update_account_form(
        &gw2,
        acct_form("9999", "220380", "tcp://182.254.242.81:30001", ""),
    );
    // 表单里放**真实形状**的前置(30 字符),核查输入位能否看全一根前置。
    shared.set_ctp_form(acct_form(
        "9999",
        "278153",
        "tcp://182.254.242.81:30001",
        "tcp://182.254.242.81:30011",
    ));
    shared.set_accounts_window_open(true);
    let mut harness = harness_for(&shared);
    harness.run();
    assert!(harness.query_by_label(&gw1).is_some(), "账户行 1 在场");
    assert!(harness.query_by_label(&gw2).is_some(), "账户行 2 在场");
    // Commit B 列表口径:添加钮在列表**上方**,窗内不再内嵌一张共享表单。
    assert!(
        harness.query_by_label_contains("当前行情源 =").is_some(),
        "列表上方须有行情源一览"
    );
    assert!(
        harness.query_by_label_contains("账户 2 个").is_some(),
        "计数在场(0.9.10:软上限口径撤除,只数个数 —— 用户裁定「从来没有限制」)"
    );
    assert!(
        harness.query_by_label("td 前置").is_some(),
        "td 前置列在场(用户裁定:配了什么 IP/端口就要显示)"
    );
    assert!(
        harness
            .query_all_by_label_contains("tcp://182.254.242.81:30001")
            .count()
            >= 2,
        "两行的 td 前置整串直显(行即数据,不是藏进弹窗才看得见)"
    );
    assert!(
        harness.query_by_label_contains("收录").is_some(),
        "收录列在场(0.9.10:只显勾选意图,勾/实并排口径退役)"
    );
}

/// s39b(0.5.0,用户定「链进行的状态改为事件日志推送」):账户表「阶段」列显形网关推的链状态。
///
/// 三条判据:① 表头有「阶段」这一列;② 推过状态行的那一格显示**去前缀的正文**;③ 它在整张窗里
/// 恰好一处 —— 混进状态列那一格(那里是「实例装配 + 状态口读数」的口径)就是串了两栏的职责。
#[test]
fn s39b_account_panel_chain_stage_column() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = Arc::new(UiShared::new());
    feed_rows(&shared, demo_rows());
    let (gw1, gw2) = two_accounts(&shared);
    shared.note_chain(&gw1, "结算单已确认");
    shared.set_accounts_window_open(true);
    let mut harness = harness_for(&shared);
    harness.run();
    assert!(
        harness.query_by_label("阶段").is_some(),
        "账户表须有「阶段」列(0.5.0 加栏;整串精确匹配,不撞窗下方那句口径)"
    );
    assert_eq!(
        harness.query_all_by_label_contains("结算单已确认").count(),
        1,
        "gw1 的阶段格 = 最近一条 `[链] ` 状态行正文(不带前缀),且只此一处"
    );
    assert_eq!(
        shared.account(&gw2).unwrap().chain_note,
        None,
        "没推过状态行的账户不凭空有阶段(那一格显示「—」)"
    );
    // 状态列口径不串:链状态不进 `status_label()`(它是「实例装配 + 登录态」两栏)。
    assert!(
        !shared
            .account(&gw1)
            .unwrap()
            .status_label()
            .contains("结算单已确认"),
        "状态列文案实测 {}",
        shared.account(&gw1).unwrap().status_label()
    );
}

// ============ 0.2.18 Commit B(账户列表 + 配置弹窗)新增钉 s40–s45 ============

/// s40 配置弹窗钉(**添加模式**):操作行给「保存并连接」、dirty 提示在场(关闭 = 放弃)
/// —— 都在语义树里。(原来配一张弹窗快照,看图这条已撤除。)
#[test]
fn s40_account_add_dialog() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = Arc::new(UiShared::new());
    feed_rows(&shared, demo_rows());
    shared.set_accounts_window_open(true);
    let mut harness = harness_for(&shared);
    harness.run();
    click_account_add(&mut harness);
    harness.run();
    shared.set_ctp_form(acct_form(
        "9999",
        "278153",
        "tcp://182.254.242.81:30001",
        "tcp://182.254.242.81:30011",
    ));
    shared.set_edit_alias("主账户");
    harness.run();
    assert!(
        harness.query_by_label("保存并连接").is_some(),
        "添加模式给『保存并连接』"
    );
    assert!(
        harness.query_by_label_contains("有未保存修改").is_some(),
        "dirty 提示在场(关闭 = 放弃)"
    );
}

/// s41 配置弹窗钉(**编辑模式**):broker/账号只读口径句 + 非源账户 md 位置灰口径句 +
/// 网关实际收录回带两处上屏 —— 全部走语义树计数。(原来配一张弹窗快照,已撤除。)
#[test]
fn s41_account_edit_dialog() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = Arc::new(UiShared::new());
    feed_rows(&shared, demo_rows());
    let (_gw1, gw2) = two_accounts(&shared);
    shared.update_account_form(
        &gw2,
        acct_form("9999", "220380", "tcp://182.254.242.81:30001", ""),
    );
    shared.set_account_alias(&gw2, "从账户");
    shared.note_effective_product_classes(&gw2, &["1".to_string(), "2".to_string()]);
    shared.set_accounts_window_open(true);
    let mut harness = harness_for(&shared);
    harness.run();
    click_row_action(&mut harness, &gw2, "编辑");
    harness.run();
    assert_eq!(shared.editing_account().as_deref(), Some(gw2.as_str()));
    assert!(
        harness
            .query_by_label_contains("要改这两格请『移除后重加』")
            .is_some(),
        "编辑模式 broker/账号只读口径句(规划 Q25)"
    );
    assert!(
        harness
            .query_by_label_contains("非行情源账户:md 位留空")
            .is_some(),
        "非源 + 已锁定 → md 位置灰口径句(规划 Q12)"
    );
    assert_eq!(
        harness.query_all_by_label_contains("期货+期权").count(),
        1,
        "网关实际收录回带只上弹窗只读区(0.9.10:列表收录列只显勾选意图,「实:」回带撤除)",
    );
}

/// s42 别名(规划 Q3 / U10):别名上列表、上按钮文案,但**不参与寻址** ——
/// `Connect` / `Remove` 指令里的网关仍是派生注册名;重名别名被拦且弹窗不关。
#[test]
fn s42_alias_shown_but_not_addressable() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = Arc::new(UiShared::new());
    feed_rows(&shared, demo_rows());
    shared.set_accounts_window_open(true);
    let mut harness = harness_for(&shared);
    harness.run();
    click_account_add(&mut harness);
    harness.run();
    shared.set_ctp_form(acct_form(
        "9999",
        "278153",
        "tcp://10.0.0.1:40001",
        "tcp://10.0.0.1:40011",
    ));
    shared.set_edit_alias("主账户");
    harness.run();
    click_dialog(&mut harness, "保存");
    let acc = shared
        .account("ctp_9999_278153")
        .expect("带别名保存须入清册");
    assert_eq!(acc.alias, "主账户", "别名随行入册");
    harness.run();
    assert!(
        harness.query_by_label("主账户").is_some(),
        "别名上列表(别名列)"
    );
    // 0.9.10 光杆口径:钮不带显示名(行即对象);行带定行后三钮都在场。
    assert!(
        row_action_exists(&harness, "ctp_9999_278153", "移除"),
        "该行须有『移除』钮(钮不再取别名)"
    );
    assert!(
        row_action_exists(&harness, "ctp_9999_278153", "编辑"),
        "该行须有『编辑』钮"
    );
    assert!(
        harness.query_by_label("移除 主账户").is_none()
            && harness.query_by_label("编辑 主账户").is_none()
            && harness.query_by_label("连接 主账户").is_none(),
        "钮文案一律光杆(0.9.10 用户裁定:编辑就编辑,移除就移除)"
    );
    // 寻址仍是派生名:行内『连接』钮发出的指令里网关仍是派生名。
    assert!(
        row_action_exists(&harness, "ctp_9999_278153", "连接"),
        "连接钮在场(同一行各钮口径一致)"
    );
    click_row_action(&mut harness, "ctp_9999_278153", "连接");
    let cmds = shared.drain_cmds();
    assert_eq!(cmds.len(), 1, "连接仍是一条令: {cmds:?}");
    match &cmds[0] {
        UiCmd::Connect { gateway, .. } => assert_eq!(
            gateway, "ctp_9999_278153",
            "别名不参与寻址(网关位仍是派生注册名)"
        ),
        other => panic!("expected Connect, got {other:?}"),
    }

    // 重名别名:第二个账户用同一别名 → 保存被拦,弹窗不关,清册不增行。
    click_account_add(&mut harness);
    harness.run();
    shared.set_ctp_form(ek_ui::state::CtpForm {
        td_user: "220380".to_string(),
        td_addr: "tcp://10.0.0.1:40001".to_string(),
        td_password: "pw-2".to_string(),
        ..shared.ctp_form()
    });
    shared.set_edit_alias("主账户");
    harness.run();
    click_dialog(&mut harness, "保存");
    assert!(
        shared.account("ctp_9999_220380").is_none(),
        "重名别名须被拦(别名唯一)"
    );
    assert!(shared.account_edit_open(), "被拦不得关弹窗");
    assert!(
        shared
            .edit_error()
            .map(|e| e.contains("别名"))
            .unwrap_or(false),
        "拦截原因须点名别名: {:?}",
        shared.edit_error()
    );
    assert_eq!(shared.accounts().len(), 1, "清册不增行");
}

/// s43 软上限(规划 §3.6):达 `MAX_ACCOUNTS` 后『添加账户』钮撤场 + 提示句在场,
/// 第 9 个账户开不出配置弹窗(界面侧先拦,不给宿主侧注定被拒的请求)。
#[test]
fn s43_soft_cap_hides_add_button() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = Arc::new(UiShared::new());
    feed_rows(&shared, demo_rows());
    for i in 0..ek_ui::state::MAX_ACCOUNTS {
        let row = ek_ui::state::AccountRow::derive(&ek_ui::state::CtpForm {
            broker_id: "9999".to_string(),
            td_addr: "tcp://10.0.0.1:40001".to_string(),
            td_user: format!("17{i:04}"),
            td_password: "fake-pw-1234".to_string(),
            td_app_id: "fake-app".to_string(),
            td_auth_code: "fake-auth".to_string(),
            ..Default::default()
        })
        .expect("派生注册名");
        shared.add_account(row).expect("账户入册");
    }
    assert!(!shared.can_add_account(), "达软上限");
    shared.set_accounts_window_open(true);
    let mut harness = harness_for(&shared);
    harness.run();
    assert!(
        harness
            .query_by_label(ek_ui::render::BTN_ACCOUNT_ADD)
            .is_none(),
        "达限后『添加账户』钮撤场(不是灰着让人白点)"
    );
    assert!(
        harness.query_by_label_contains("账户 64 个").is_some(),
        "0.9.10 口径:达防御顶只数个数,不再挂软上限提示句(用户裁定「从来没有限制」)"
    );
    assert_eq!(
        harness.query_all_by_label_contains("未装配").count(),
        ek_ui::state::MAX_ACCOUNTS,
        "六十四行账户状态列都是『未装配』"
    );
}

/// s44 『保存并连接』(规划 §3.3 四态):保存 + **一条** Connect 令(不是两令),弹窗关闭。
#[test]
fn s44_save_and_connect_single_command() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = Arc::new(UiShared::new());
    feed_rows(&shared, demo_rows());
    shared.set_accounts_window_open(true);
    let mut harness = harness_for(&shared);
    harness.run();
    click_account_add(&mut harness);
    harness.run();
    shared.set_ctp_form(acct_form(
        "9999",
        "278153",
        "tcp://10.0.0.1:40001",
        "tcp://10.0.0.1:40011",
    ));
    harness.run();
    click_dialog(&mut harness, "保存并连接");
    assert!(!shared.account_edit_open(), "成功 = 弹窗关闭");
    assert_eq!(shared.accounts().len(), 1, "先写清册");
    let cmds = shared.drain_cmds();
    assert_eq!(cmds.len(), 1, "『保存并连接』= 一条 Connect 令: {cmds:?}");
    assert!(matches!(cmds[0], UiCmd::Connect { .. }));
    assert!(
        !row_action_exists(&harness, "ctp_9999_278153", "连接"),
        "已入列连接的行不再给『连接』钮(避免重复入列)"
    );
}

/// s45 『先撤 N 笔』出口(规划 U10):守卫不能只堵门 —— 按该账户活跃委托逐笔入列
/// `CancelOrder`,网关位 = 该账户自己的派生名(与「全撤」同一条 oms 通道)。
#[test]
fn s45_cancel_all_before_remove_entry() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = Arc::new(UiShared::new());
    feed_rows(&shared, demo_rows());
    let (_, gw2) = two_accounts(&shared);
    shared.seed_trade_snap(ek_ui::state::TradeSnap {
        orders: vec![
            ek_data::order::OrderData {
                gateway_name: gw2.clone(),
                symbol: "rb2605".to_string(),
                exchange: ek_data::constant::Exchange::SHFE,
                orderid: format!("{gw2}.CTP_9_1"),
                status: ek_data::constant::Status::NOTTRADED,
                ..ek_data::order::OrderData::default()
            },
            ek_data::order::OrderData {
                gateway_name: gw2.clone(),
                symbol: "cu2709".to_string(),
                exchange: ek_data::constant::Exchange::SHFE,
                orderid: format!("{gw2}.CTP_9_2"),
                status: ek_data::constant::Status::NOTTRADED,
                ..ek_data::order::OrderData::default()
            },
        ],
        ..ek_ui::state::TradeSnap::default()
    });
    shared.set_accounts_window_open(true);
    let mut harness = harness_for(&shared);
    harness.run();
    harness.get_by_label("先撤 2 笔").click_accesskit();
    harness.run();
    let cmds = shared.drain_cmds();
    assert_eq!(cmds.len(), 2, "两笔活跃委托逐笔入列: {cmds:?}");
    for c in &cmds {
        match c {
            UiCmd::CancelOrder { gateway, .. } => {
                assert_eq!(gateway, &gw2, "撤单随单走(该账户自己的派生名)")
            }
            other => panic!("expected CancelOrder, got {other:?}"),
        }
    }
    let (lines, _) = shared.logs_snapshot();
    assert!(
        lines
            .iter()
            .any(|l| l.contains("先撤") && l.contains("撤完才可移除")),
        "出口须留痕: {lines:?}"
    );
}

/// s46 非 modal 弹窗 × 摘除的连带口径(执行核查抓到的坑):弹窗开着时点同一行『移除』
/// → 必须连带关弹窗放弃。否则编辑目标消失后弹窗会静默退化成「添加模式」
/// (只读句消失、字段全可编辑),点『保存』会拿旧凭据建出一个**新账户**。
#[test]
fn s46_remove_while_editing_closes_dialog() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = Arc::new(UiShared::new());
    feed_rows(&shared, demo_rows());
    let (_gw1, gw2) = two_accounts(&shared);
    shared.update_account_form(
        &gw2,
        acct_form("9999", "220380", "tcp://10.0.0.1:40001", ""),
    );
    shared.set_accounts_window_open(true);
    let mut harness = harness_for(&shared);
    harness.run();
    click_row_action(&mut harness, &gw2, "编辑");
    harness.run();
    assert!(shared.account_edit_open(), "编辑弹窗已开");
    assert_eq!(
        shared.editing_account().as_deref(),
        Some(gw2.as_str()),
        "编辑模式 = 该行"
    );

    // 弹窗开着 → 同一行『移除』二次确认 → 摘除成功且弹窗**连带关闭**(0.9.10 光杆口径)。
    click_row_action(&mut harness, &gw2, "移除");
    click_row_action(&mut harness, &gw2, "确认移除?");
    harness.run();
    let cmds = shared.drain_cmds();
    assert!(
        cmds.iter()
            .any(|c| matches!(c, UiCmd::Remove { name } if name == &gw2)),
        "摘除令入列: {cmds:?}"
    );
    assert!(shared.account(&gw2).is_none(), "行已摘");
    assert!(
        !shared.account_edit_open(),
        "摘除须连带关弹窗(不得留下退化成『添加模式』的编辑窗)"
    );
    assert!(shared.editing_account().is_none(), "编辑模式解除");
    assert!(
        shared.ctp_form().td_password.is_empty(),
        "连带放弃:草稿位凭据清空(旧凭据不得留在共享位)"
    );

    // 防御层二:编辑不存在的账户 = 不开窗(即使外部拿着陈旧 gateway 串)。
    let before = shared.accounts().len();
    assert!(
        !shared.begin_account_edit(Some(&gw2)),
        "编辑不在清册的账户须被拒"
    );
    assert!(!shared.account_edit_open(), "不开窗");
    assert_eq!(shared.accounts().len(), before, "清册不变");
}

/// s47 下单归属下拉 × 摘除(执行核查补的洞):清册非空时,已摘除账户的网关不得留在
/// 下单下拉里,且表单里「选过它」的残留选择须就地回落到默认阶梯并落盘 ——
/// 否则下一笔单注定撞 `unknown:gateway`。撤单不受影响(随每笔单自己的网关走)。
#[test]
fn s47_removed_gateway_leaves_order_dropdown() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = Arc::new(UiShared::new());
    feed_rows(&shared, demo_rows());
    let (gw1, gw2) = two_accounts(&shared);
    // 表单手动选过 gw2(模拟"上一笔单挂在从账户上")。
    let mut f = shared.order_form();
    f.gateway = gw2.clone();
    shared.set_order_form(f);
    shared.set_accounts_window_open(true);
    let mut harness = harness_for(&shared);
    harness.run();
    assert!(
        harness.query_by_label(&gw2).is_some(),
        "摘除前:下单下拉选中 gw2"
    );

    click_row_action(&mut harness, &gw2, "移除");
    click_row_action(&mut harness, &gw2, "确认移除?");
    harness.run();
    shared.drain_cmds();
    harness.run();

    assert!(
        harness.query_by_label(&gw1).is_some(),
        "在场账户仍是下单下拉的选中项(默认阶梯)"
    );
    assert!(
        harness.query_by_label(&gw2).is_none(),
        "已摘除网关不得留在下单下拉(选它 = unknown:gateway)"
    );
    assert_eq!(
        shared.order_form().gateway,
        gw1,
        "表单里的陈旧选择须就地回落并落盘"
    );
    assert_eq!(
        shared.default_gateway().as_deref(),
        Some(gw1.as_str()),
        "默认阶梯只认已装配账户"
    );
}

// ---- 0.2.19 状态面钉(s48–s52):登录态徽标 / 断供两判据 / 问不到退回 / 『断开』 ----

/// 造一份网关状态读数(ek-ctp 0.9.0 `GatewayStatus`;其余位走 Default = 全 false/0/None)。
fn status_of(
    gateway: &str,
    f: impl FnOnce(&mut ek_ctp::plugin::GatewayStatus),
) -> ek_ctp::plugin::GatewayStatus {
    let mut st = ek_ctp::plugin::GatewayStatus {
        gateway: gateway.to_string(),
        sampled_ms: ek_ctp::map::now_epoch_ms(),
        ..Default::default()
    };
    f(&mut st);
    st
}

/// s48 状态列随读数变:在线 / 掉线×N / 登录失败 三档各自显形,且**旧读数一律不留档**。
///
/// 关键判据:`td_handle_up = true` 而 `td_logged_in = false` 时必须显示「掉线」而不是「在线」
/// —— 网关的"句柄已建"在掉线时仍是真(ek-ctp DESIGN D-STATUS ①),界面照抄它就等于谎称在线。
#[test]
fn s48_login_badge_follows_gateway_status_readings() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = Arc::new(UiShared::new());
    feed_rows(&shared, demo_rows());
    let (gw1, _gw2) = two_accounts(&shared);
    // 状态读数分 TD/MD 两侧,判据是「该行的 td 前置留档非空」。
    // `two_accounts` 的夹具表单没有前置(它只测派生名与单源纪律),这里补上,
    // 否则测到的是 MD 半边分支(s48–s50 要的是 TD 半边)。
    shared.update_account_form(
        &gw1,
        acct_form(
            "9999",
            "278153",
            "tcp://127.0.0.1:30001",
            "tcp://127.0.0.1:30011",
        ),
    );
    shared.set_accounts_window_open(true);
    let mut harness = harness_for(&shared);
    // 0.3.2(Wave E)连带:toast 在屏上时 egui-notify 每帧 request_repaint(退场计时),
    // `Harness::run()` 的 max_steps = 4 会直接炸 —— 有活计时器就不能指望「UI 自己静下来」。
    // 改成定帧数(比 run() 更确定,run() 本来就最多跑 4 帧)。
    harness.run_steps(4);
    assert_eq!(
        harness
            .query_all_by_label_contains("已装配·登录态未知")
            .count(),
        2,
        "起点:两行都还没有读数"
    );

    let now = ek_ctp::map::now_epoch_ms();
    // 读数一:登录成功 + 刚有资金回报 → 在线(唯一硬证据 = td_logged_in)。
    shared.note_gateway_status(
        &gw1,
        &status_of(&gw1, |st| {
            st.td_handle_up = true;
            st.td_logged_in = true;
            st.td_last_login_ok_ms = Some(now);
            st.td_last_account_ms = Some(now);
        }),
    );
    // 0.3.2(Wave E)连带:toast 在屏上时 egui-notify 每帧 request_repaint(退场计时),
    // `Harness::run()` 的 max_steps = 4 会直接炸 —— 有活计时器就不能指望「UI 自己静下来」。
    // 改成定帧数(比 run() 更确定,run() 本来就最多跑 4 帧)。
    harness.run_steps(4);
    assert!(
        harness.query_by_label("已装配·在线").is_some(),
        "读到 td_logged_in → 「已装配·在线」"
    );
    assert_eq!(
        harness
            .query_all_by_label_contains("已装配·登录态未知")
            .count(),
        1,
        "另一行不受影响,仍是未知"
    );

    // 读数二:句柄还在、登录掉了、断线计数 2 → 掉线(且细节带次数)。
    shared.note_gateway_status(
        &gw1,
        &status_of(&gw1, |st| {
            st.td_handle_up = true;
            st.td_logged_in = false;
            st.td_disconnects = 2;
            st.td_last_error = Some("柜台连接断开".to_string());
        }),
    );
    // 0.3.2(Wave E)连带:toast 在屏上时 egui-notify 每帧 request_repaint(退场计时),
    // `Harness::run()` 的 max_steps = 4 会直接炸 —— 有活计时器就不能指望「UI 自己静下来」。
    // 改成定帧数(比 run() 更确定,run() 本来就最多跑 4 帧)。
    harness.run_steps(4);
    assert!(
        harness
            .query_all_by_label_contains("已装配·掉线")
            .collect::<Vec<_>>()
            .iter()
            .any(|n| n.rect().width() > 0.0),
        "handle_up 真而 logged_in 假 → 掉线(不得显示在线;告警带柜台短因 = 文本比档名长)"
    );
    assert_eq!(
        harness.query_all_by_label_contains("已装配·在线").count(),
        0,
        "旧读数不得留档"
    );
    assert!(
        shared
            .account(&gw1)
            .unwrap()
            .status_note
            .clone()
            .unwrap_or_default()
            .contains("掉线 2 次"),
        "细节(F2 取证入口)住在 status_note(0.9.10:面板底部细节段退役,全量在事件日志)"
    );

    // 读数三:登录失败与掉线是两档(网关侧 td_login_failed 独立于 disconnects)。
    shared.note_gateway_status(
        &gw1,
        &status_of(&gw1, |st| {
            st.td_handle_up = true;
            st.td_login_failed = true;
            st.td_last_error = Some("登录被拒:账号或密码错误".to_string());
        }),
    );
    // 0.3.2(Wave E)连带:toast 在屏上时 egui-notify 每帧 request_repaint(退场计时),
    // `Harness::run()` 的 max_steps = 4 会直接炸 —— 有活计时器就不能指望「UI 自己静下来」。
    // 改成定帧数(比 run() 更确定,run() 本来就最多跑 4 帧)。
    harness.run_steps(4);
    assert!(
        harness.query_by_label_contains("已装配·登录失败").is_some(),
        "登录失败独立显形(与掉线不混成一档)"
    );
    assert!(
        shared
            .account(&gw1)
            .unwrap()
            .status_note
            .clone()
            .unwrap_or_default()
            .contains("登录被拒:账号或密码错误"),
        "网关的原始错误文本须进 status_note(0.9.10:上屏位 = 状态列短因 + 事件日志全句)"
    );
}

/// s49 「查询断供」两判据(规划 Q10):连续被拒达阈 **或** 资金回报超时;阈值可覆盖。
///
/// 阈值住在界面不住在网关:ek-ctp 只给 `td_query_reject_streak` 与时刻,
/// 「几次算断供 / 多久算断供」是界面口径。缺省 3 次 / 30 秒。
#[test]
fn s49_query_starved_two_criteria_and_thresholds() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = Arc::new(UiShared::new());
    feed_rows(&shared, demo_rows());
    let (gw1, _gw2) = two_accounts(&shared);
    // 状态读数分 TD/MD 两侧,判据是「该行的 td 前置留档非空」。
    // `two_accounts` 的夹具表单没有前置(它只测派生名与单源纪律),这里补上,
    // 否则测到的是 MD 半边分支(s48–s50 要的是 TD 半边)。
    shared.update_account_form(
        &gw1,
        acct_form(
            "9999",
            "278153",
            "tcp://127.0.0.1:30001",
            "tcp://127.0.0.1:30011",
        ),
    );
    shared.set_accounts_window_open(true);
    let mut harness = harness_for(&shared);
    // 0.3.2(Wave E)连带:toast 在屏上时 egui-notify 每帧 request_repaint(退场计时),
    // `Harness::run()` 的 max_steps = 4 会直接炸 —— 有活计时器就不能指望「UI 自己静下来」。
    // 改成定帧数(比 run() 更确定,run() 本来就最多跑 4 帧)。
    harness.run_steps(4);
    let now = ek_ctp::map::now_epoch_ms();

    // 判据一(未达阈):连续被拒 2 次 < 缺省 3 → 仍算在线,不冤枉正在重试的账户。
    shared.note_gateway_status(
        &gw1,
        &status_of(&gw1, |st| {
            st.td_handle_up = true;
            st.td_logged_in = true;
            st.td_last_account_ms = Some(now);
            st.td_query_rejects = 2;
            st.td_query_reject_streak = 2;
        }),
    );
    // 0.3.2(Wave E)连带:toast 在屏上时 egui-notify 每帧 request_repaint(退场计时),
    // `Harness::run()` 的 max_steps = 4 会直接炸 —— 有活计时器就不能指望「UI 自己静下来」。
    // 改成定帧数(比 run() 更确定,run() 本来就最多跑 4 帧)。
    harness.run_steps(4);
    assert!(
        harness.query_by_label("已装配·在线").is_some(),
        "2 次被拒没达阈值 3 → 不算断供"
    );

    // 判据一(达阈):第 3 次 → 断供,细节带次数。
    shared.note_gateway_status(
        &gw1,
        &status_of(&gw1, |st| {
            st.td_handle_up = true;
            st.td_logged_in = true;
            st.td_last_account_ms = Some(now);
            st.td_query_rejects = 3;
            st.td_query_reject_streak = 3;
        }),
    );
    // 0.3.2(Wave E)连带:toast 在屏上时 egui-notify 每帧 request_repaint(退场计时),
    // `Harness::run()` 的 max_steps = 4 会直接炸 —— 有活计时器就不能指望「UI 自己静下来」。
    // 改成定帧数(比 run() 更确定,run() 本来就最多跑 4 帧)。
    harness.run_steps(4);
    assert!(
        harness.query_by_label_contains("已装配·查询断供").is_some(),
        "连续被拒达阈 → 查询断供"
    );
    assert!(
        shared
            .account(&gw1)
            .unwrap()
            .status_note
            .clone()
            .unwrap_or_default()
            .contains("查询连续被拒 3 次"),
        "细节须说清是哪一判据命中的(status_note 数据面)"
    );

    // 判据二:登录着、一次都没被拒,但资金回报 60 秒没更新 → 也是断供(带秒数)。
    shared.note_gateway_status(
        &gw1,
        &status_of(&gw1, |st| {
            st.td_handle_up = true;
            st.td_logged_in = true;
            st.td_last_account_ms = Some(now - 60_000);
        }),
    );
    // 0.3.2(Wave E)连带:toast 在屏上时 egui-notify 每帧 request_repaint(退场计时),
    // `Harness::run()` 的 max_steps = 4 会直接炸 —— 有活计时器就不能指望「UI 自己静下来」。
    // 改成定帧数(比 run() 更确定,run() 本来就最多跑 4 帧)。
    harness.run_steps(4);
    assert!(
        harness.query_by_label_contains("已装配·查询断供").is_some(),
        "登录着但资金回报超时 → 同样断供(被拒 0 次不豁免)"
    );
    assert!(
        shared
            .account(&gw1)
            .unwrap()
            .status_note
            .clone()
            .unwrap_or_default()
            .contains("资金回报已 60s 未更新"),
        "细节须带超时秒数(status_note 数据面)"
    );

    // 登录着、资金一次都没到手:轮转第一拍本就要几秒 → 在线 + 写明「尚未到手」,不冤枉成断供。
    shared.note_gateway_status(
        &gw1,
        &status_of(&gw1, |st| {
            st.td_handle_up = true;
            st.td_logged_in = true;
            st.td_last_login_ok_ms = Some(now);
        }),
    );
    // 0.3.2(Wave E)连带:toast 在屏上时 egui-notify 每帧 request_repaint(退场计时),
    // `Harness::run()` 的 max_steps = 4 会直接炸 —— 有活计时器就不能指望「UI 自己静下来」。
    // 改成定帧数(比 run() 更确定,run() 本来就最多跑 4 帧)。
    harness.run_steps(4);
    assert!(
        harness.query_by_label("已装配·在线").is_some(),
        "「从未回报过」≠「断供」(None 不当 0 用)"
    );

    // 阈值覆盖:夹具收紧到「1 次 / 30 秒」后,1 次被拒即断供。
    shared.set_status_thresholds(1, 30);
    assert_eq!(shared.status_thresholds(), (1, 30), "覆盖位须可读回");
    shared.note_gateway_status(
        &gw1,
        &status_of(&gw1, |st| {
            st.td_handle_up = true;
            st.td_logged_in = true;
            st.td_last_account_ms = Some(ek_ctp::map::now_epoch_ms());
            st.td_query_reject_streak = 1;
        }),
    );
    // 0.3.2(Wave E)连带:toast 在屏上时 egui-notify 每帧 request_repaint(退场计时),
    // `Harness::run()` 的 max_steps = 4 会直接炸 —— 有活计时器就不能指望「UI 自己静下来」。
    // 改成定帧数(比 run() 更确定,run() 本来就最多跑 4 帧)。
    harness.run_steps(4);
    assert!(
        harness.query_by_label_contains("已装配·查询断供").is_some(),
        "阈值覆盖生效:1 次被拒即断供"
    );
}

/// s50 状态口问不到(网关不在场 / ask 超时)→ 退回「登录态未知」并写明原因。
///
/// 这一钉守的是反向谎称:上一轮读到「在线」,这一轮问不到时**不得把「在线」留在屏上**
/// —— 问不到就是没有证据。
#[test]
fn s50_unreachable_status_falls_back_to_unknown() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = Arc::new(UiShared::new());
    feed_rows(&shared, demo_rows());
    let (gw1, _gw2) = two_accounts(&shared);
    // 状态读数分 TD/MD 两侧,判据是「该行的 td 前置留档非空」。
    // `two_accounts` 的夹具表单没有前置(它只测派生名与单源纪律),这里补上,
    // 否则测到的是 MD 半边分支(s48–s50 要的是 TD 半边)。
    shared.update_account_form(
        &gw1,
        acct_form(
            "9999",
            "278153",
            "tcp://127.0.0.1:30001",
            "tcp://127.0.0.1:30011",
        ),
    );
    shared.set_accounts_window_open(true);
    let mut harness = harness_for(&shared);
    harness.run();

    let now = ek_ctp::map::now_epoch_ms();
    shared.note_gateway_status(
        &gw1,
        &status_of(&gw1, |st| {
            st.td_handle_up = true;
            st.td_logged_in = true;
            st.td_last_account_ms = Some(now);
        }),
    );
    harness.run();
    assert!(
        harness.query_by_label("已装配·在线").is_some(),
        "先读到在线"
    );

    shared.note_status_unreachable(&gw1, "ask 超时");
    harness.run();
    assert_eq!(
        harness.query_all_by_label_contains("已装配·在线").count(),
        0,
        "问不到时旧「在线」必须消失"
    );
    assert_eq!(
        harness
            .query_all_by_label_contains("已装配·登录态未知")
            .count(),
        2,
        "两行都回到未知(问不到 = 没有证据)"
    );
    assert!(
        shared
            .account(&gw1)
            .unwrap()
            .status_note
            .clone()
            .unwrap_or_default()
            .contains("状态口问不到"),
        "须写明为什么未知(status_note 数据面 + 事件日志;0.9.10 面板细节段退役)"
    );
}

/// s51 『断开』钮:入列 `UiCmd::Disconnect`(不是 Remove);回执后徽标「已断开」、
/// 『断开』消失、『连接』回来(裁定 1:断开 = 停会话,实例与订阅保留,『连接』可恢复)。
#[test]
fn s51_disconnect_button_enqueues_and_badge_follows() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = Arc::new(UiShared::new());
    feed_rows(&shared, demo_rows());
    let (gw1, _gw2) = two_accounts(&shared);
    // 状态读数分 TD/MD 两侧,判据是「该行的 td 前置留档非空」。
    // `two_accounts` 的夹具表单没有前置(它只测派生名与单源纪律),这里补上,
    // 否则测到的是 MD 半边分支(s48–s50 要的是 TD 半边)。
    shared.update_account_form(
        &gw1,
        acct_form(
            "9999",
            "278153",
            "tcp://127.0.0.1:30001",
            "tcp://127.0.0.1:30011",
        ),
    );
    shared.set_accounts_window_open(true);
    let mut harness = harness_for(&shared);
    harness.run();

    click_row_action(&mut harness, &gw1, "断开");
    harness.run();
    let cmds = shared.drain_cmds();
    assert!(
        cmds.iter()
            .any(|c| matches!(c, UiCmd::Disconnect { gateway } if gateway == &gw1)),
        "『断开』须入列 Disconnect(不是 Remove:那是停实例,另一颗钮)"
    );
    assert!(
        !cmds.iter().any(|c| matches!(c, UiCmd::Remove { .. })),
        "『断开』不得顺手发移除令"
    );
    assert!(
        shared
            .logs_snapshot()
            .0
            .iter()
            .any(|l| l.contains("断开") && l.contains("已入列")),
        "按了钮须有一条入列日志"
    );

    // 插件侧回执(等价于 run_cmds 里 ask `{gw}.disconnect` 成功后的 mark_account_stopped)。
    shared.mark_account_stopped(&gw1);
    harness.run();
    assert!(
        harness.query_by_label("已装配·已断开").is_some(),
        "回执后徽标 = 已断开(装配态不变:实例还在)"
    );
    assert!(
        !row_action_exists(&harness, &gw1, "断开"),
        "会话已停的行不再给『断开』钮(没有会话可停)"
    );
    assert!(
        row_action_exists(&harness, &gw1, "连接"),
        "恢复入口仍是『连接』(插件侧走「已在场 → 重投凭据」)"
    );
    assert!(
        row_action_exists(&harness, &gw1, "移除"),
        "『移除』与『断开』并存:两个动作两条口,不共用"
    );
}

/// s52 未装配的行没有『断开』钮(规划 Q21:口不存在/无会话可停时不留死钮)。
#[test]
fn s52_not_assembled_row_has_no_disconnect_button() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = Arc::new(UiShared::new());
    feed_rows(&shared, demo_rows());
    let (gw1, gw2) = two_accounts(&shared);
    // 第三行:只写清册,不装配(规划裁定「添加 ≠ 连接」)。
    let gw3 =
        ek_ui::state::AccountRow::derive(&acct_form("9999", "777001", "tcp://127.0.0.1:30001", ""))
            .expect("派生注册名")
            .gateway;
    assert_ne!(gw3, gw1);
    assert_ne!(gw3, gw2);
    shared
        .add_account(
            ek_ui::state::AccountRow::derive(&acct_form(
                "9999",
                "777001",
                "tcp://127.0.0.1:30001",
                "",
            ))
            .expect("派生"),
        )
        .expect("添加第三账户");
    shared.set_accounts_window_open(true);
    let mut harness = harness_for(&shared);
    harness.run();

    assert!(harness.query_by_label(&gw3).is_some(), "第三行在场");
    assert!(
        !row_action_exists(&harness, &gw3, "断开"),
        "未装配 = 没有会话可停,不留死钮(Q21)"
    );
    assert!(
        row_action_exists(&harness, &gw3, "连接"),
        "未装配给『连接』"
    );
    assert!(
        row_action_exists(&harness, &gw1, "断开"),
        "已装配那行仍给『断开』"
    );
}

/// s53 纯行情账户看 MD 半边:td 前置留档为空的行,状态口 TD 读数永远全假,
/// 照抄它只会得到「未知」——那是假信息,必须改看 `md_logged_in`。
#[test]
fn s53_md_only_row_reads_the_md_side() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = Arc::new(UiShared::new());
    feed_rows(&shared, demo_rows());
    let (gw1, _gw2) = two_accounts(&shared);
    // 把 gw1 的留档改成"只有行情前置"(TD 半边空)。
    shared.update_account_form(
        &gw1,
        acct_form("9999", "278153", "", "tcp://127.0.0.1:30011"),
    );
    shared.set_accounts_window_open(true);
    let mut harness = harness_for(&shared);
    harness.run();

    let now = ek_ctp::map::now_epoch_ms();
    // TD 半边全假、MD 半边登录成功 → 必须「在线」。
    shared.note_gateway_status(
        &gw1,
        &status_of(&gw1, |st| {
            st.md_handle_up = true;
            st.md_logged_in = true;
            st.md_last_login_ok_ms = Some(now);
            st.md_last_tick_ms = Some(now);
            st.md_subscribed = 1;
        }),
    );
    harness.run();
    assert!(
        harness.query_by_label("已装配·在线").is_some(),
        "纯行情账户的在线证据在 MD 半边"
    );
    assert!(
        shared
            .account(&gw1)
            .unwrap()
            .status_note
            .clone()
            .unwrap_or_default()
            .contains("纯行情账户"),
        "细节须写明这一行没有 TD 会话(status_note 数据面;0.9.10 面板细节段退役)"
    );

    // MD 掉线同样显形(带次数)。
    shared.note_gateway_status(
        &gw1,
        &status_of(&gw1, |st| {
            st.md_handle_up = true;
            st.md_disconnects = 3;
        }),
    );
    // 0.3.2(Wave E,BD-UI-50)连带:MD 掉线是告警态 → 状态轮询回写直接灌 toast(不再等账户窗),
    // toast 在屏时每帧 request_repaint → `run()` 的「等 UI 静下来」炸。改定帧数。
    harness.run_steps(4);
    assert!(
        harness.query_by_label_contains("已装配·掉线").is_some(),
        "MD 掉线同样显形"
    );
    assert!(
        shared
            .account(&gw1)
            .unwrap()
            .status_note
            .clone()
            .unwrap_or_default()
            .contains("掉线 3 次"),
        "细节带次数(status_note 数据面)"
    );
    // 纯行情账户没有 TD 查询,不参与「查询断供」判定。
    assert_eq!(
        harness.query_all_by_label_contains("查询断供").count(),
        0,
        "TD 判据不得套在纯行情账户上"
    );
}

/// s54 『断开』与『移除』共用同一道活跃委托守卫:柜台还在跑单时不画『断开』。
///
/// 为什么必须同守卫:会话一停就撤不了单、也不再回报 —— 与『移除』要挡的是同一个
/// 观测黑洞(规划 §5.B)。出口也同一个:旁边那句『先撤 N 笔』。
#[test]
fn s54_disconnect_respects_active_order_guard() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = Arc::new(UiShared::new());
    feed_rows(&shared, demo_rows());
    let (gw1, gw2) = two_accounts(&shared);
    shared.seed_trade_snap(ek_ui::state::TradeSnap {
        orders: vec![ek_data::order::OrderData {
            gateway_name: gw2.clone(),
            symbol: "rb2605".to_string(),
            exchange: ek_data::constant::Exchange::SHFE,
            orderid: format!("{gw2}.CTP_9_1"),
            status: ek_data::constant::Status::NOTTRADED,
            ..ek_data::order::OrderData::default()
        }],
        ..ek_ui::state::TradeSnap::default()
    });
    shared.set_accounts_window_open(true);
    let mut harness = harness_for(&shared);
    harness.run();

    // gw2 有 1 笔活跃委托:『断开』不画(不是画出来再禁用),出口在场(0.9.10 光杆口径:
    // 守卫句本体 = 行带里没有断开/移除 + 有『先撤 N 笔』;文案句退役)。
    assert!(
        !row_action_exists(&harness, &gw2, "断开"),
        "有活跃委托时不画『断开』(会话一停就撤不了单)"
    );
    assert!(
        !row_action_exists(&harness, &gw2, "移除"),
        "有活跃委托时不画『移除』(同一个观测黑洞)"
    );
    assert!(
        row_action_exists(&harness, &gw2, "先撤 1 笔"),
        "守卫须给出口"
    );
    // 没有委托的 gw1 照常可断。
    assert!(
        row_action_exists(&harness, &gw1, "断开"),
        "无活跃委托的已装配账户仍可断开"
    );

    // 撤完(快照清空)后同一行的『断开』必须出现 —— 守卫是状态闸,不是一次性禁用。
    shared.seed_trade_snap(ek_ui::state::TradeSnap::default());
    harness.run();
    assert!(
        row_action_exists(&harness, &gw2, "断开"),
        "委托撤完『断开』即恢复"
    );
    assert!(
        row_action_exists(&harness, &gw2, "移除"),
        "同一行『移除』也在场(两个动作两条口)"
    );
    assert_eq!(gw1, "ctp_9999_278153", "寻址仍是派生名");
}

/// s55 实例被摘除后,登录态读数一并作废:徽标回「未装配」,状态细节不得留着。
///
/// 会话读数属于那个实例。实例没了还印「已装配·掉线 / 掉线 2 次」,
/// 就是替一个已经不存在的会话说话。
#[test]
fn s55_removed_instance_voids_its_status_readings() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = Arc::new(UiShared::new());
    feed_rows(&shared, demo_rows());
    let (gw1, gw2) = two_accounts(&shared);
    shared.update_account_form(
        &gw1,
        acct_form(
            "9999",
            "278153",
            "tcp://127.0.0.1:30001",
            "tcp://127.0.0.1:30011",
        ),
    );
    shared.set_accounts_window_open(true);
    let mut harness = harness_for(&shared);
    // 0.3.2(Wave E)连带:toast 在屏上时 egui-notify 每帧 request_repaint(退场计时),
    // `Harness::run()` 的 max_steps = 4 会直接炸 —— 有活计时器就不能指望「UI 自己静下来」。
    // 改成定帧数(比 run() 更确定,run() 本来就最多跑 4 帧)。
    harness.run_steps(4);

    shared.note_gateway_status(
        &gw1,
        &status_of(&gw1, |st| {
            st.td_handle_up = true;
            st.td_disconnects = 2;
        }),
    );
    // 0.3.2(Wave E)连带:toast 在屏上时 egui-notify 每帧 request_repaint(退场计时),
    // `Harness::run()` 的 max_steps = 4 会直接炸 —— 有活计时器就不能指望「UI 自己静下来」。
    // 改成定帧数(比 run() 更确定,run() 本来就最多跑 4 帧)。
    harness.run_steps(4);
    assert!(
        harness.query_by_label_contains("已装配·掉线").is_some(),
        "先读到掉线"
    );
    assert!(
        shared
            .account(&gw1)
            .unwrap()
            .status_note
            .is_some(),
        "细节数据在场(status_note;0.9.10 面板细节段退役,取证走事件日志)"
    );

    // svctl 快照不再带回这两个名字(被摘/宿主崩了)。
    shared.sync_accounts_connected(&[row("svctl"), row("dm"), row("oms")]);
    // 0.3.2(Wave E)连带:toast 在屏上时 egui-notify 每帧 request_repaint(退场计时),
    // `Harness::run()` 的 max_steps = 4 会直接炸 —— 有活计时器就不能指望「UI 自己静下来」。
    // 改成定帧数(比 run() 更确定,run() 本来就最多跑 4 帧)。
    harness.run_steps(4);
    assert_eq!(
        harness.query_all_by_label_contains("未装配").count(),
        2,
        "两行都回「未装配」"
    );
    assert_eq!(
        harness.query_all_by_label_contains("已装配·掉线").count(),
        0,
        "实例不在场了还印「掉线」= 替不存在的会话说话"
    );
    assert_eq!(
        harness.query_all_by_label_contains("状态细节").count(),
        0,
        "状态细节同样不得留着(只给已装配的行)"
    );
    let rows = shared.accounts();
    let a = rows.iter().find(|r| r.gateway == gw1).expect("行还在");
    assert_eq!(a.stage, ek_ui::state::AccountStage::NotAssembled);
    assert_eq!(a.login, ek_ui::state::LoginState::Unknown, "读数作废");
    assert!(a.status_note.is_none(), "细节作废");
    assert!(
        row_action_exists(&harness, &gw1, "连接"),
        "回「未装配」即重新给『连接』钮"
    );
    assert!(
        !row_action_exists(&harness, &gw1, "断开"),
        "没有实例就没有会话可停"
    );
    assert_eq!(gw2, "ctp_9999_220380");
}

/// s56(Q17 收口,0.2.20):账户清册里的实例不在运维窗起停。
///
/// 账户面板的『移除』带全套守卫(活跃委托闸 + 二次确认 + 持仓提示),运维窗那条是
/// 同一动作的无守卫副本 —— 同一个实例两条移除路、守卫只长在一条上,等于守卫可绕过。
/// 实例仍列在表里(看得见),给的是去处而不是死钮。
#[test]
fn s56_ops_window_leaves_account_instances_to_the_account_panel() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = Arc::new(UiShared::new());
    feed_rows(
        &shared,
        vec![
            row("svctl"),
            row("dm"),
            row("oms"),
            row("ui"),
            row("ctp_9999_278153"),
        ],
    );
    let (gw1, _gw2) = two_accounts(&shared);
    shared.set_ops_window_open(true);
    let mut harness = harness_for(&shared);
    harness.run();

    // 工厂插件照旧可在运维窗起停。
    assert!(
        row_action_exists(&harness, "dm", "移除"),
        "工厂插件仍可在运维窗移除"
    );
    assert!(
        row_action_exists(&harness, "oms", "重注入"),
        "工厂插件仍可重注入"
    );
    // 账户实例仍列在表里(运维可见性不砍)。
    assert!(
        harness.query_by_label_contains("ctp_9999_278153").is_some(),
        "账户实例仍列在运维表里"
    );
    assert!(
        !row_action_exists(&harness, "ctp_9999_278153", "移除"),
        "清册里的实例不在运维窗移除(Q17 边界收口)"
    );
    assert!(
        !row_action_exists(&harness, "ctp_9999_278153", "重注入"),
        "同上:重注入对命名实例本来就是 unknown factory"
    );
    assert!(
        row_action_exists(&harness, "ctp_9999_278153", "归账户面板"),
        "给出的是去处,不是死钮"
    );
    assert_eq!(gw1, "ctp_9999_278153");
}

/// s56b(0.4.3 BD-UI-64,审核 P1):管制面与观测面自身不在运维窗摘除。
///
/// `svctl.list` 的行来自 `engine.plugin_names()`,里面本来就有 `svctl` 与 `ui` 自己。
/// 摘 svctl 是单向门(工厂表不登记它,连『重注入 svctl』也只会回 unknown factory);
/// 摘 ui 是自己等自己(`UiCmd` 由 ui 自己的 worker 在 eTimer 拍上执行,只能走到
/// ek-core `close_one` 的 2 秒超时 detach 分支)。这一钉只管画不画:
/// 真链钉在 tests/ui_ops.rs 的 t2(两条闸各在两侧:supervisor 拒 svctl、UiPlugin 直拒 ui)。
#[test]
fn s56b_ops_window_refuses_removing_the_control_and_observation_faces() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = Arc::new(UiShared::new());
    feed_rows(
        &shared,
        vec![row("svctl"), row("dm"), row("oms"), row("ui")],
    );
    shared.set_ops_window_open(true);
    let mut harness = harness_for(&shared);
    harness.run();

    // 两条自身行:没有『移除』钮(光杆钮行带定位:自身行带里只给重注入)。
    assert!(
        !row_action_exists(&harness, "svctl", "移除"),
        "管制面自身不得给移除钮(摘掉即单向门)"
    );
    assert!(
        !row_action_exists(&harness, "ui", "移除"),
        "观测面自身不得给移除钮(摘掉即自己等自己)"
    );
    // 给的是徽章(说明进 tooltip),不是死钮(两条自身行各一处 = 2)。
    assert_eq!(
        harness.query_all_by_label_contains("自身不摘").count(),
        2,
        "两条自身行都要给徽章(说明在 tooltip,不在行内长句)"
    );
    // 两条自身行都在表里(可见性不砍),『重注入』照旧在场。
    assert!(
        row_action_exists(&harness, "svctl", "重注入")
            && row_action_exists(&harness, "ui", "重注入"),
        "重注入不砍:在场时撞宿主 Duplicate → svctl 回拒,无害"
    );
    // 工厂插件那条路不受影响(与 s56 同一口径)。
    assert!(
        row_action_exists(&harness, "dm", "移除"),
        "工厂插件仍可在运维窗移除"
    );
}

/// s57(F4 口径显形,0.2.20):「谁查谁过滤」写死成一句话,面板与弹窗各一处。
///
/// 实连 S14b:账户 B 把勾选改成「期货+期权」,公用合约表仍 852 条、期权 0 条 ——
/// 用户没有任何办法判断是自己没生效还是网关没查到。
#[test]
fn s57_product_class_scope_is_stated_in_panel_and_dialog() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = Arc::new(UiShared::new());
    feed_rows(&shared, demo_rows());
    let (_gw1, _gw2) = two_accounts(&shared);
    shared.set_accounts_window_open(true);
    let mut harness = harness_for(&shared);
    harness.run();

    // (0.9.10:面板底部 F4 句随说明行退役 —— 用户裁定「表下不留杂说明」;
    //  口径句唯一在场位 = 配置弹窗(改勾选的现场))。
    assert_eq!(
        harness
            .query_all_by_label_contains("公用合约表 = 在场各网关的并集(合约与行情公用,规划 D3)")
            .count(),
        0,
        "面板底部不再有 F4 长句"
    );
    click_row_action(&mut harness, "ctp_9999_278153", "编辑");
    harness.run();
    // 同一句常量在弹窗在场(唯一现场位)。
    assert_eq!(
        harness
            .query_all_by_label_contains("收录勾选只管该网关自己收录并上抛的合约")
            .count(),
        1,
        "配置弹窗一处(F4 口径唯一在场位)"
    );
    assert_eq!(
        harness
            .query_all_by_label_contains("改勾选须『连接/重试』才下发到网关")
            .count(),
        1,
        "生效条件同位在场"
    );
}

/// s58(接 ek-ctp 0.9.1 分项,0.2.20):合约查询被拒在状态细节里点名,且不重复点名。
///
/// 总数与连续串不分路(消费侧要的是「查询这条路连续被拒几次」),但用户要知道被拒的
/// 是哪一路:合约一条没到手时,下一笔单会被 ContractGate 以 `contract:unknown` 拒掉,
/// 而状态列只写「在线」就是假信息。
#[test]
fn s58_instrument_query_rejection_is_named_in_status_detail() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = Arc::new(UiShared::new());
    feed_rows(&shared, demo_rows());
    let (gw1, _gw2) = two_accounts(&shared);
    shared.update_account_form(
        &gw1,
        acct_form(
            "9999",
            "278153",
            "tcp://127.0.0.1:30001",
            "tcp://127.0.0.1:30011",
        ),
    );
    shared.set_accounts_window_open(true);
    let mut harness = harness_for(&shared);
    // 0.3.2(Wave E)连带:toast 在屏上时 egui-notify 每帧 request_repaint(退场计时),
    // `Harness::run()` 的 max_steps = 4 会直接炸 —— 有活计时器就不能指望「UI 自己静下来」。
    // 改成定帧数(比 run() 更确定,run() 本来就最多跑 4 帧)。
    harness.run_steps(4);
    let now = ek_ctp::map::now_epoch_ms();

    // 一:登录着、资金刚到手,但合约查询被拒过一次(未达断供阈)→ 在线 + 点名。
    shared.note_gateway_status(
        &gw1,
        &status_of(&gw1, |st| {
            st.td_handle_up = true;
            st.td_logged_in = true;
            st.td_last_login_ok_ms = Some(now);
            st.td_last_account_ms = Some(now);
            st.td_query_rejects = 1;
            st.td_query_reject_streak = 1;
            st.td_instrument_rejects = 1;
        }),
    );
    // 0.3.2(Wave E)连带:toast 在屏上时 egui-notify 每帧 request_repaint(退场计时),
    // `Harness::run()` 的 max_steps = 4 会直接炸 —— 有活计时器就不能指望「UI 自己静下来」。
    // 改成定帧数(比 run() 更确定,run() 本来就最多跑 4 帧)。
    harness.run_steps(4);
    assert!(
        harness.query_by_label("已装配·在线").is_some(),
        "连续串 1 未达阈 3:不算断供"
    );
    assert!(
        shared
            .account(&gw1)
            .unwrap()
            .status_note
            .clone()
            .unwrap_or_default()
            .contains("合约查询被拒 1 次"),
        "0.9.1 分项须在状态数据里(status_note;0.9.10 面板细节段退役)"
    );

    // 二:连续串达阈 → 断供句 + 分项句并存,且分项只点名一次。
    shared.note_gateway_status(
        &gw1,
        &status_of(&gw1, |st| {
            st.td_handle_up = true;
            st.td_logged_in = true;
            st.td_last_login_ok_ms = Some(now);
            st.td_last_account_ms = Some(now);
            st.td_query_rejects = 3;
            st.td_query_reject_streak = 3;
            st.td_instrument_rejects = 2;
        }),
    );
    // 0.3.2(Wave E)连带:toast 在屏上时 egui-notify 每帧 request_repaint(退场计时),
    // `Harness::run()` 的 max_steps = 4 会直接炸 —— 有活计时器就不能指望「UI 自己静下来」。
    // 改成定帧数(比 run() 更确定,run() 本来就最多跑 4 帧)。
    harness.run_steps(4);
    assert!(
        harness.query_by_label_contains("已装配·查询断供").is_some(),
        "连续串达阈 → 断供"
    );
    let rows = shared.accounts();
    let a = rows.iter().find(|r| r.gateway == gw1).expect("行还在");
    let note = a.status_note.clone().unwrap_or_default();
    assert!(
        note.contains("查询连续被拒 3 次") && note.contains("合约查询被拒 2 次"),
        "两句并存,分路看得见: {note}"
    );
    assert_eq!(
        note.matches("合约查询被拒").count(),
        1,
        "同一件事不重复点名: {note}"
    );

    // 三:分项为 0 = 不加句子(健康行的状态细节不无谓变长)。
    shared.note_gateway_status(
        &gw1,
        &status_of(&gw1, |st| {
            st.td_handle_up = true;
            st.td_logged_in = true;
            st.td_last_login_ok_ms = Some(now);
            st.td_last_account_ms = Some(now);
        }),
    );
    // 0.3.2(Wave E)连带:toast 在屏上时 egui-notify 每帧 request_repaint(退场计时),
    // `Harness::run()` 的 max_steps = 4 会直接炸 —— 有活计时器就不能指望「UI 自己静下来」。
    // 改成定帧数(比 run() 更确定,run() 本来就最多跑 4 帧)。
    harness.run_steps(4);
    let rows = shared.accounts();
    let a = rows.iter().find(|r| r.gateway == gw1).expect("行还在");
    assert!(
        a.status_note.is_none(),
        "没有事实就不写句子: {:?}",
        a.status_note
    );
}

/// s59(日志窗口径,0.2.20):溢出后界面必须说清「这是窗口不是历史」。
///
/// 巡回 G1 的实连证据:重加账户后 90 秒内没抓到「交易服务器登录成功」行,但同一账户
/// 的资金行下一拍就刷新了 —— 登录其实成功,是 512 行环被状态推送流挤满把登录行顶掉了。
/// 取证的事实源是网关状态口(状态列 + 状态细节),不是日志回扫。
#[test]
fn s59_log_window_says_it_is_a_window_not_history() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    // A/D 波(0.9.9):本测试一次灌 RING_CAP+3 条合成行 —— 不重定向就把
    // 4099 条假 [demo] 行全部写进真机取证文件(%APPDATA%\ek\logs\)。指出局。
    // SAFETY:测试单点;并行下其他测试同时构造环会读两态目录(只影响落盘去向,
    // 无共享断言受害);断言只看本测试自己的画面。
    unsafe {
    std::env::set_var(
        "EK_UI_LOG_DIR",
        std::env::temp_dir().join(format!("ek-ui-s59-{}", std::process::id())),
    );
    }
    let shared = Arc::new(UiShared::new());
    feed_rows(&shared, demo_rows());
    // 日志面板只在右下组「日志」tab 在场(默认不是它)。
    shared.set_bottomright_tab(ek_ui::state::BottomRightTab::Logs);
    for i in 0..(ek_ui::state::RING_CAP + 3) {
        shared.log_line(format!("[INFO][demo] 状态推送 {i:04}"));
    }
    let mut harness = harness_for(&shared);
    harness.run();
    assert!(
        harness
            .query_by_label_contains("日志窗是窗口不是历史")
            .is_some(),
        "溢出时必须把口径说出来(光有『已丢弃 N 条』不够)"
    );
    assert!(
        harness.query_by_label_contains("别回扫这里").is_some(),
        "并给出该去哪儿"
    );
    // D 之后"去哪儿"有了真答案:落盘文件指针必须在场(A/D 裁定文案追句)。
    assert!(
        harness
            .query_by_label_contains("全量在盘:%APPDATA%\\ek\\logs\\")
            .is_some(),
        "全量取证文件路径必须显形,否则落盘能力在界面上隐形"
    );
    // 计数本身仍在场(溢出事实不抹)。
    assert!(
        harness.query_by_label_contains("已丢弃 3 条").is_some(),
        "溢出计数显形"
    );
}

/// s60(0.2.21 第三条断供判据,实连 S15f 逼出来的):登录着、一次查询都没被拒、
/// 但资金回报**从未到手** —— 超过 stale 阈值必须翻「查询断供」,不得永远显示「在线」。
///
/// 实连证据(2026-10-22 runA/runB):账户 B `logged_in=true`、`td_query_rejects=0`、
/// `td_last_account_ms=None` 持续 390 秒以上 —— 旧口径下它一直是「在线 + 资金回报尚未到手」。
#[test]
fn s60_never_received_account_report_becomes_starved() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = Arc::new(UiShared::new());
    feed_rows(&shared, demo_rows());
    let (gw1, _gw2) = two_accounts(&shared);
    shared.update_account_form(
        &gw1,
        acct_form(
            "9999",
            "278153",
            "tcp://127.0.0.1:30001",
            "tcp://127.0.0.1:30011",
        ),
    );
    shared.set_accounts_window_open(true);
    let mut harness = harness_for(&shared);
    // 0.3.2(Wave E)连带:toast 在屏上时 egui-notify 每帧 request_repaint(退场计时),
    // `Harness::run()` 的 max_steps = 4 会直接炸 —— 有活计时器就不能指望「UI 自己静下来」。
    // 改成定帧数(比 run() 更确定,run() 本来就最多跑 4 帧)。
    harness.run_steps(4);
    let now = ek_ctp::map::now_epoch_ms();

    // 刚登录 5 秒:还没到手 = 在线 + 一句话(轮转第一拍本就要 2~6 秒,不能算断供)。
    shared.note_gateway_status(
        &gw1,
        &status_of(&gw1, |st| {
            st.td_handle_up = true;
            st.td_logged_in = true;
            st.td_last_login_ok_ms = Some(now - 5_000);
        }),
    );
    // 0.3.2(Wave E)连带:toast 在屏上时 egui-notify 每帧 request_repaint(退场计时),
    // `Harness::run()` 的 max_steps = 4 会直接炸 —— 有活计时器就不能指望「UI 自己静下来」。
    // 改成定帧数(比 run() 更确定,run() 本来就最多跑 4 帧)。
    harness.run_steps(4);
    assert!(
        harness.query_by_label("已装配·在线").is_some(),
        "刚登录几秒不算断供"
    );
    assert!(
        shared
            .account(&gw1)
            .unwrap()
            .status_note
            .clone()
            .unwrap_or_default()
            .contains("资金回报尚未到手"),
        "这句话在 status_note(0.9.10 面板细节段退役)"
    );

    // 登录已 40 秒、资金一次都没到手、查询被拒 0 次 → 断供(实连 B 的形状)。
    shared.note_gateway_status(
        &gw1,
        &status_of(&gw1, |st| {
            st.td_handle_up = true;
            st.td_logged_in = true;
            st.td_last_login_ok_ms = Some(now - 40_000);
        }),
    );
    // 0.3.2(Wave E)连带:toast 在屏上时 egui-notify 每帧 request_repaint(退场计时),
    // `Harness::run()` 的 max_steps = 4 会直接炸 —— 有活计时器就不能指望「UI 自己静下来」。
    // 改成定帧数(比 run() 更确定,run() 本来就最多跑 4 帧)。
    harness.run_steps(4);
    assert!(
        harness.query_by_label_contains("已装配·查询断供").is_some(),
        "从未到手超时即断供(不得永远在线)"
    );
    let rows = shared.accounts();
    let a = rows.iter().find(|r| r.gateway == gw1).expect("行还在");
    let note = a.status_note.clone().unwrap_or_default();
    assert!(
        note.contains("资金回报从未到手(登录已 40s)"),
        "细节要带时长: {note}"
    );

    // 真到手即回在线(判据不粘)。
    shared.note_gateway_status(
        &gw1,
        &status_of(&gw1, |st| {
            st.td_handle_up = true;
            st.td_logged_in = true;
            st.td_last_login_ok_ms = Some(now - 40_000);
            st.td_last_account_ms = Some(now);
        }),
    );
    // 0.3.2(Wave E)连带:toast 在屏上时 egui-notify 每帧 request_repaint(退场计时),
    // `Harness::run()` 的 max_steps = 4 会直接炸 —— 有活计时器就不能指望「UI 自己静下来」。
    // 改成定帧数(比 run() 更确定,run() 本来就最多跑 4 帧)。
    harness.run_steps(4);
    assert!(
        harness.query_by_label("已装配·在线").is_some(),
        "到手即回在线"
    );
}

// ================= BD-UI-41(0.2.27):对照 Python 版逐项补齐的界面面 =================

/// s63:日志 tab 是一张**带表头的表**。
/// Python 侧「日志」区放的是 `LogMonitor` —— 带「时间/信息/接口」表头的
/// QTableWidget(`widget.py:1167-1180`),跟着 Dock 伸展。我们原来是一坨
/// monospace 行 + `ScrollArea::max_height(180.0)`:既没有表头,也不会随窗口长高
/// (用户实看报的「整体放到最大,日志那边表格还是很小」根因就是那 180)。
#[test]
fn s63_logs_tab_is_a_table_with_headers() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = Arc::new(UiShared::new());
    feed_rows(&shared, demo_rows());
    shared.log_line("[ops] 日志表格化第一行");
    shared.log_line("[订阅] 日志表格化第二行");
    shared.set_bottomright_tab(ek_ui::state::BottomRightTab::Logs);
    let mut harness = harness_for(&shared);
    let hit = ek_ui::fonts::apply_cjk_fonts(&harness.ctx);
    assert!(hit.is_some(), "验收环境必须有 CJK 候选字体");
    harness.run();
    // 「时间」不唯一:行情带 14 列里也有「时间」列 → 用 query_all 数个数,
    // 日志表头出现后必须从 1 变 2。
    let t = harness.query_all_by_label("时间").count();
    assert!(
        t >= 2,
        "日志表必须有『时间』表头(行情带也有一列,实测 {t} 处)"
    );
    assert!(
        harness.query_by_label("信息").is_some(),
        "日志表必须有『信息』表头(全画面唯一)"
    );
    assert!(
        harness
            .query_by_label_contains("日志表格化第一行")
            .is_some()
    );
    assert!(
        harness
            .query_by_label_contains("日志表格化第二行")
            .is_some()
    );
}

/// s64:每个组都带 tab 头(0.4.1 BD-UI-54:tab 条回归原生 `tab_label`)。
/// Python 四个区全是 QTabWidget(`mainwindow.py:126-173`)。判据 = 三条 tab 条的
/// 全部标签**进 AccessKit 可点**(0.4.0 dock 时代「tab 查不到」的绕路作废)+
/// 前台格内容真的画出来(防「tab 在、内容空」)。
#[test]
fn s64_trades_and_positions_cells_have_tab_heads() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = Arc::new(UiShared::new());
    feed_rows(&shared, demo_rows());
    let mut harness = harness_for(&shared);
    let hit = ek_ui::fonts::apply_cjk_fonts(&harness.ctx);
    assert!(hit.is_some(), "验收环境必须有 CJK 候选字体");
    harness.run();

    // ① 三条 tab 条的全部标签都在 AccessKit 树里(用 query_all:tab 名与数据格/
    //    下单钮同名是 Python 口径的常态,唯一性判据不放在这条上):
    //    行情带 6 所 + 委托|未成交 + 资金|日志 + 成交/持仓两张单 tab 头。
    for ex in ek_ui::state::MARKET_ORDER {
        // 0.4.1 九期 BD-UI-62:tab 标签 = 交易所**中文名**(用户裁定「不要显示交易所的代码」)。
        let name = ek_ui::render::exchange_tab_name(ex);
        assert!(
            harness.query_all_by_label(name).count() >= 1,
            "{name}({}) 行情 tab 头缺失",
            ex.as_str()
        );
    }
    for tab_head in ["委托", "未成交", "资金", "日志", "成交", "持仓"] {
        assert!(
            harness.query_all_by_label(tab_head).count() >= 1,
            "{tab_head} tab 头缺失"
        );
    }

    // ② 前台格的内容真在屏上:成交 / 持仓 / 委托 / 资金 四张表各取一个**表头字**
    // (0.4.1 六期 BD-UI-59 起资金格无账户时不再画空态文案,画的是表头 —— 同 s26 口径)。
    for head in ["成交金额", "均价"] {
        assert!(
            harness.query_by_label(head).is_some(),
            "{head} 表头缺失:前台格内容没画出来"
        );
    }
    assert!(
        harness.query_by_label("权益").is_some(),
        "资金格表头「权益」缺失(前台格内容没画出来;0.8.5 起「余额」改名「权益」)"
    );
    assert!(
        harness.query_all_by_label("委托号").count() >= 2,
        "委托号表头必须同时出现在委托表与成交表"
    );
}

/// s65:运维窗「服务」目录表补表头(用户指出「配置那边表格也要有表头」)。
/// 原来这张六列表是纯数据没有头行;列语义 = 三对「服务名 / 实例 id」。
#[test]
fn s65_service_directory_table_has_headers() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = Arc::new(UiShared::new());
    feed_snapshot(
        &shared,
        vec![
            ("dm".to_string(), vec!["dm.1".to_string()]),
            ("oms".to_string(), vec![]),
        ],
    );
    shared.set_ops_window_open(true);
    let mut harness = harness_for(&shared);
    let hit = ek_ui::fonts::apply_cjk_fonts(&harness.ctx);
    assert!(hit.is_some(), "验收环境必须有 CJK 候选字体");
    harness.run();
    // 这张表是「三对 服务名/实例 id」→ 表头就该有 3 个「服务」+ 3 个「实例」;
    // 「服务」再多一处是分区标题(`ui.label("服务")`)。数据格写的是「dm 服务」,不撞名。
    let s = harness.query_all_by_label("服务").count();
    assert!(
        s >= 4,
        "服务目录表必须有 3 处『服务』表头 + 1 处标题,实测 {s}"
    );
    let i = harness.query_all_by_label("实例").count();
    assert_eq!(
        i, 3,
        "服务目录表必须有 3 处『实例』表头(与三对列同数),实测 {i}"
    );
}

/// 表头带候选:该色实心矩形中「够宽够高」的那些(1px 框线 / 下边线不算带)。
///
/// **圆角闸**(0.4.1 九期 BD-UI-62):表头带一律 `rect_filled(.., 0.0, ..)` = 方角;
/// `tab_label` 的 tab 头底用的是 `widgets.inactive.corner_radius`(圆角)且同色同实心
/// —— 行情带 tab 条从「表上」移到「表下」后,tab 头就贴在表头带旁边,不加这道闸就会被
/// 数成表头带(实撞:s79 极差 3.0 px = 26.0 的 tab 头混进 29.0 的带里)。
fn header_bands(shapes: &[egui::Shape], color: egui::Color32, min_w: f32) -> Vec<egui::Rect> {
    shapes
        .iter()
        .filter_map(|s| match s {
            egui::Shape::Rect(r)
                if r.fill == color
                    && r.stroke.is_empty()
                    && r.corner_radius == egui::CornerRadius::ZERO
                    && r.rect.width() >= min_w
                    && r.rect.height() >= 8.0 =>
            {
                Some(r.rect)
            }
            _ => None,
        })
        .collect()
}

/// 区域内「这一帧真被画出来的文字」最宽跨度 = 体表宽度(形状版;裁剪后为空的文字不算)。
fn text_span_in(shapes: &[egui::epaint::ClippedShape], region: egui::Rect) -> f32 {
    let mut lo = f32::INFINITY;
    let mut hi = f32::NEG_INFINITY;
    for cs in shapes {
        let egui::Shape::Text(t) = &cs.shape else {
            continue;
        };
        let visible = t.visual_bounding_rect().intersect(cs.clip_rect);
        if !visible.is_positive() || !region.contains_rect(visible) {
            continue;
        }
        lo = lo.min(visible.min.x);
        hi = hi.max(visible.max.x);
    }
    if hi < lo { 0.0 } else { hi - lo }
}

/// s67:表头带与选中 tab 下划线必须**真的在这一帧画出来**,不是只写在代码里。
/// 判据取主题令牌(不写死色值):`BG4` = 表头带底、`ACCENT4` = 选中 tab 的下划线、
/// `BG5` = 选中 tab 的底。0.4.1 四期(BD-UI-57)换色板后这三档的角色不变,值换:
/// Nova 下 = `#262626` / `#E5E5E5` / `#404040`(旧 qdarkstyle 是 `#455364` / `#259AE9`
/// / `#54687A`,qss:1959-1970 / 1592)。
/// 改前:表头带填的是 `panel_fill`(= 表体同色)→ 用户看到的「只有背景没有线」;
/// 下划线一处都没有。判据从「数像素」换成「数这一帧的绘制指令」(HANDOVER §17)。
///
/// 0.4.0 起 tab 那两档曾由 **dock 自己画**(`dock::dock_style` 把这三档钉成令牌);
/// 0.4.1(BD-UI-54)拆 dock 后回到自绘 `tab_label` —— 本钉跟着派生路径,不变。
#[test]
fn s67_chrome_is_actually_painted() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = Arc::new(UiShared::new());
    feed_rows(&shared, demo_rows());
    let mut harness = harness_for(&shared);
    let hit = ek_ui::fonts::apply_cjk_fonts(&harness.ctx);
    assert!(hit.is_some(), "验收环境必须有 CJK 候选字体");
    harness.run();
    let shapes = shapes_of(&harness);
    let bands = header_bands(&shapes, ek_ui::tokens::shadcn::BG4, 200.0);
    let band_area: f32 = bands.iter().map(|r| r.area()).sum();
    assert!(
        !bands.is_empty() && band_area > 4_000.0,
        "表头带(BG4 实心、够宽够高)必须成片出现,实测 {} 根 / 面积 {band_area:.0}",
        bands.len()
    );
    let underline = hlines(&shapes, ek_ui::tokens::shadcn::ACCENT4);
    assert!(
        !underline.is_empty(),
        "选中 tab 的下划线(ACCENT4)必须出现在绘制指令里,实测 {} 根",
        underline.len()
    );
    let tab_fill = filled_rects(&shapes, ek_ui::tokens::shadcn::BG5);
    assert!(
        !tab_fill.is_empty(),
        "选中 tab 的底(BG5)必须出现在绘制指令里,实测 {} 块",
        tab_fill.len()
    );
}

/// s69(BD-UI-42,用户实看钉):运维窗两张表(插件表 / 服务目录)的表头带
/// 必须盖住整行 —— 原来带只到『操作』列表头文字的右端,两个按钮压在没带的底色上。
/// 判据形状:带 = 本帧绘制指令里**盖住表头格**的 BG4 实心矩形(表头格从语义树取,
/// 不硬编码浮动窗在画面哪一块);体表 = 带下方、带 x 范围内真被画出来(裁剪后非空)的文字跨度。
/// 原来这条靠 `harness.render()` 扫像素 + 硬编码窗口区域。
#[test]
fn s69_ops_window_header_band_covers_the_row() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = Arc::new(UiShared::new());
    feed_snapshot(
        &shared,
        vec![
            ("dm".to_string(), vec!["dm.1".to_string()]),
            ("oms".to_string(), vec![]),
        ],
    );
    shared.set_ops_window_open(true);
    let mut harness = harness_for(&shared);
    let hit = ek_ui::fonts::apply_cjk_fonts(&harness.ctx);
    assert!(hit.is_some(), "验收环境必须有 CJK 候选字体");
    harness.run();
    let clipped = clipped_shapes_of(&harness);
    let shapes: Vec<egui::Shape> = clipped.iter().map(|c| c.shape.clone()).collect();
    // 两张表的表头格(「统计」= 插件表专属,「实例」= 服务目录三对列)。
    let heads: Vec<egui::Rect> = ["统计", "实例"]
        .iter()
        .flat_map(|h| harness.query_all_by_label(h).map(|n| n.rect()))
        .collect();
    assert!(
        heads.len() >= 4,
        "运维窗必须有插件表「统计」+ 服务目录 3 处「实例」表头,实测 {}",
        heads.len()
    );
    let all_bands = header_bands(&shapes, ek_ui::tokens::shadcn::BG4, 100.0);
    let bands: Vec<egui::Rect> = all_bands
        .iter()
        .filter(|b| heads.iter().any(|h| b.contains_rect(*h)))
        .copied()
        .collect();
    assert!(
        !bands.is_empty(),
        "运维窗的表头带必须真的盖住表头格(BG4 实心矩形),实测本帧带 {all_bands:?}"
    );
    assert!(
        bands.iter().any(|b| b.width() > 400.0),
        "运维窗里必须有一根整行表头带(宽 > 400),实测 {:?}",
        bands.iter().map(|b| b.width()).collect::<Vec<_>>()
    );
    // 已知遗留(0.2.30 记入交接报告 §7.1 待办,美化轮收):浮动窗是**自动尺寸**的,
    // 窗宽在帧末才按内容定,而表头带在 Grid 之后就用当帧的 `max_rect` 画完 →
    // 带比这一帧的表体短一截(缺口在『操作』列那两只按钮之外)。本轮不修,
    // 判据按「缺口 ≤ 90 px」钉住,不许它继续变大。
    for band in &bands {
        let body_region = egui::Rect::from_min_max(
            egui::pos2(band.min.x, band.max.y + 1.0),
            egui::pos2(band.max.x, band.max.y + 160.0),
        );
        let body = text_span_in(&clipped, body_region);
        assert!(
            band.width() + 90.0 >= body,
            "表头带盖住体表最宽一行的缺口必须 ≤ 90 px(带 {:.1} px / 体表 {:.1} px,带 {band:?})",
            band.width(),
            body
        );
    }
}

/// s70(BD-UI-42):资金格的表带同样要盖住整行(资金表只有五列、列宽由数据撑开,
/// 原来带比体表窄一截)。判据同 s69:带取绘制指令,体表取真画出来的文字跨度。
#[test]
fn s70_funds_table_band_covers_the_row() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = Arc::new(UiShared::new());
    shared.seed_trade_snap(ek_ui::state::TradeSnap {
        accounts: vec![
            ek_data::account::AccountData {
                gateway_name: "ctp_9999_278153".to_string(),
                accountid: "278153".to_string(),
                balance: 19_929_826.41,
                frozen: 12_345.67,
            },
            ek_data::account::AccountData {
                gateway_name: "ctp_9999_220380".to_string(),
                accountid: "220380".to_string(),
                balance: 1_000.0,
                frozen: 0.0,
            },
        ],
        ..ek_ui::state::TradeSnap::default()
    });
    shared.set_bottomright_tab(ek_ui::state::BottomRightTab::Account);
    let mut harness = harness_for(&shared);
    let hit = ek_ui::fonts::apply_cjk_fonts(&harness.ctx);
    assert!(hit.is_some(), "验收环境必须有 CJK 候选字体");
    harness.run();
    assert!(
        harness.query_by_label("账号").is_some(),
        "资金表表头必须在(账号列)"
    );
    let clipped = clipped_shapes_of(&harness);
    let shapes: Vec<egui::Shape> = clipped.iter().map(|c| c.shape.clone()).collect();
    // 带 = 盖住「账号」表头格的那根 BG4 实心矩形(不硬编码右下格在画面哪一块:
    // 0.3.0 换 dock 容器以后位置已经挪过)。
    let head = harness
        .query_by_label("账号")
        .expect("资金表必须有「账号」表头")
        .rect();
    let bands: Vec<egui::Rect> = header_bands(&shapes, ek_ui::tokens::shadcn::BG4, 100.0)
        .into_iter()
        .filter(|b| b.contains_rect(head))
        .collect();
    assert!(
        !bands.is_empty(),
        "资金表头格必须被表头带(BG4 实心矩形)盖住,表头格 {head:?} / 本帧带 {:?}",
        header_bands(&shapes, ek_ui::tokens::shadcn::BG4, 100.0)
    );
    let band = bands
        .iter()
        .max_by(|a, b| a.width().total_cmp(&b.width()))
        .expect("上面已保证非空");
    let body_region = egui::Rect::from_min_max(
        egui::pos2(band.min.x, band.max.y + 1.0),
        egui::pos2(band.max.x, band.max.y + 200.0),
    );
    let body = text_span_in(&clipped, body_region);
    assert!(
        band.width() >= body,
        "资金表头带必须盖住体表最宽一行(带 {:.1} px < 体表 {:.1} px = 断开,带 {band:?})",
        band.width(),
        body
    );
}

/// s73(空态不吞表头,0.4.0 修正的用户实看钉):「表头恒在 + 表体内一行空态」。
///
/// 根因:资金格(`if accounts.is_empty() { muted_label; return; }`)与运维窗服务目录
/// (`if flat.is_empty() { muted_label }`)在没有数据时**整张表连表头一起不画**,只剩一句空态;
/// 行情格同病(`if ticks.is_empty()`)。资金格是「资金|日志」格的默认前台,用户第一眼看到的
/// 就是它 → 「资金和日志那边表格有问题,表头都没有」。
///
/// 判据:全空状态下(无 tick / 无账户 / 无服务 / 无日志)每个表**独有的表头文字**必须都在
/// AccessKit 里 —— 表头没了就必然红。用独有列名,避免与别的表撞名:
/// 涨跌幅(行情)、状态描述(委托)、成交金额(成交)、盈亏比(持仓)、余额(资金)、
/// 信息(日志,切格后)、实例(服务目录)、账号(账户面板)。
#[test]
fn s73_empty_state_keeps_table_headers() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = Arc::new(UiShared::new()); // 全空:没有 tick / 账户 / 快照 / 日志
    shared.set_ops_window_open(true);
    shared.set_accounts_window_open(true);
    let mut harness = harness_for(&shared);
    harness.run();

    for (head, why) in [
        ("涨跌幅", "行情格(等 eTick 订阅时)"),
        ("状态描述", "委托格"),
        ("成交金额", "成交格"),
        (
            "盈亏",
            "持仓格(0.8.5 撤死列:s73 改钉「盈亏」,这句判据仍防空态吞头)",
        ),
        ("权益", "资金格(0.8.5 起「余额」改名「权益」)"),
        ("实例", "运维窗服务目录(无服务时)"),
        ("账号", "账户面板(无账户时)"),
    ] {
        assert!(
            harness.query_all_by_label_contains(head).count() >= 1,
            "空态不得吞掉表头:{why}的表头「{head}」必须在(这就是用户看到的「表头都没有」)"
        );
    }

    // 日志格是「资金|日志」的另一个 tab,只有切过去才画:切完表头也必须在。
    shared.set_bottomright_tab(ek_ui::state::BottomRightTab::Logs);
    harness.run();
    assert!(
        harness.query_all_by_label_contains("信息").count() >= 1,
        "空态不得吞掉表头:日志格(无日志时)的表头「信息」必须在"
    );
}

/// s74(0.4.1 五期 BD-UI-58,用户裁定「没有数据时按当前表宽初始化,按表头分配各列比例」):
/// 空态表(无数据行)的表头必须把表头带**填到 85% 带宽**,不许挤在左边。
/// 实测改前(1280×860,同一套判据):行情带只铺到 51%(带右沿前空 663.8 px)、
/// 资金表 61%(空 188.4 px)、合约窗表 83%(空 95.4 px)。
/// 判据从这一帧的文字形状取:带 = 盖住这张表表头的 BG4 实心矩形;填满 = 带内最右一条
/// 表头文字的右沿相对带左沿的比例。
#[test]
fn s74_empty_tables_fill_their_header_band() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = Arc::new(UiShared::new()); // 全空:无 tick / 无账户 / 无快照 / 无日志
    let mut harness = harness_for(&shared);
    // 空态列宽种子写在 `TableState` 里,只在第一帧生效一次(库的首帧全量量测被我们
    // 跳过,见 render.rs 的注释)→ 判据必须跑够帧数再看,不能只看首帧。
    for _ in 0..4 {
        harness.run();
    }
    let shapes = shapes_of(&harness);
    let bands = header_bands(&shapes, ek_ui::tokens::shadcn::BG4, 100.0);
    for (head, why) in [("涨跌幅", "行情带(14 列)"), ("账号", "资金格(5 列)")] {
        let anchor = texts_containing(&shapes, head)
            .into_iter()
            .find(|(t, _, _)| t == head)
            .map(|(_, r, _)| r)
            .unwrap_or_else(|| panic!("s74:{why}的表头「{head}」必须在场(s73 已钉)"));
        let Some(band) = bands.iter().find(|b| b.contains_rect(anchor)) else {
            panic!("s74:{why}必须有一根盖住表头「{head}」的表头带,实测带 {bands:?}");
        };
        let rightmost = shapes
            .iter()
            .filter_map(|s| match s {
                egui::Shape::Text(t) => {
                    let r = t.visual_bounding_rect();
                    (r.center().y >= band.min.y
                        && r.center().y <= band.max.y
                        && r.min.x >= band.min.x
                        && r.min.x <= band.max.x)
                        .then_some(r.max.x)
                }
                _ => None,
            })
            .fold(f32::NEG_INFINITY, f32::max);
        let fill = (rightmost - band.min.x) / band.width();
        println!(
            "s74 {why}:带 {:.1}..{:.1}(宽 {:.1})最右表头右沿 {rightmost:.1} → 填满 {:.1}%",
            band.min.x,
            band.max.x,
            band.width(),
            fill * 100.0
        );
        assert!(
            fill >= 0.85,
            "s74:{why}空态必须按表头比例把带宽填满,实测只铺到 {:.1}%(带右沿前还空 {:.1} px)—— 这就是用户说的「表头全挤在一起」",
            fill * 100.0,
            band.max.x - rightmost
        );
    }
}

/// 表格层五张表的带身份 + 列线下限(s75 / s77 共用)。
/// 下限 = 实测留余量:空态列线 14 / 10 / 11 / 11 / 5,喂数据 14 / 10 / 9 / 12 / 6。
/// 列宽随内容长 → 可视列数会变,下限不能钉在实测值上。
const PINNED_GRID_TARGETS: [(&str, usize); 5] = [
    ("行情带(14 列)", 10),
    ("委托表(17 列)", 7),
    ("成交表(12 列)", 7),
    ("持仓表(16 列)", 9),
    ("资金格(5 列)", 4),
];

/// 带身份按几何分:行情带通窗宽(min.x 贴窗左沿、在菜单条之下),数据区是 2×2 四格。
fn pinned_band_identity(b: &egui::Rect) -> &'static str {
    if b.min.x < 100.0 && b.min.y < 100.0 {
        "行情带(14 列)"
    } else if b.min.y < 450.0 && b.min.x < 700.0 {
        "委托表(17 列)"
    } else if b.min.y < 450.0 {
        "成交表(12 列)"
    } else if b.min.x < 700.0 {
        "持仓表(16 列)"
    } else {
        "资金格(5 列)"
    }
}

/// 一张 shared 画四帧后,表格层五张表的 (带身份, 行线数, 列线数)。
/// 锚点 = 首列表头(「代码」×4 + 「账号」):库把视口外的表头列剔掉,首列永远在场。
fn pinned_grid_line_counts(shared: &UiShared) -> Vec<(String, usize, usize)> {
    let mut harness = harness_for(shared);
    for _ in 0..4 {
        harness.run();
    }
    let shapes = shapes_of(&harness);
    // 0.8.2:行线走 `BORDER_SOFT`(参考站 td 那支);表头带下边线仍是 BORDER。
    let border = ek_ui::tokens::shadcn::BORDER_SOFT;
    let bands = header_bands(&shapes, ek_ui::tokens::shadcn::BG4, 100.0);
    let hl = hlines(&shapes, border);
    // 列线计数取**任意色**(BD-UI-60 反向钉:列线已撤,换颜色不能算通过)。
    let vl = vlines_any(&shapes);
    // 行情带贴窗左沿(「代码」在 x ≈ 22),数据区四格在 x > 300;
    // 下单表单里也有「代码」「账号」字段标签(x < 300 且 y > 400)→ 两道闸都挡掉。
    let in_tables = |r: &egui::Rect| r.min.x > 300.0 || r.min.y < 100.0;
    let mut anchors: Vec<egui::Rect> = harness
        .query_all_by_label("代码")
        .map(|n| n.rect())
        .filter(in_tables)
        .collect();
    anchors.extend(
        harness
            .query_all_by_label("账号")
            .map(|n| n.rect())
            .filter(in_tables),
    );
    let mut out: Vec<(String, usize, usize)> = Vec::new();
    for a in &anchors {
        let Some(band) = bands.iter().find(|b| {
            b.min.x <= a.min.x + 2.0
                && b.max.x >= a.max.x - 2.0
                && b.min.y <= a.min.y + 2.0
                && b.max.y >= a.max.y - 2.0
        }) else {
            continue;
        };
        let rows = hl
            .iter()
            .filter(|(y, x)| {
                *y > band.max.y + 3.0
                    && *y <= band.max.y + 3.0 + 2.5 * 26.0
                    && x.span() >= band.width() * 0.7
            })
            .count();
        let cols = vl
            .iter()
            .filter(|(x, y, _)| {
                *x > band.min.x + 2.0
                    && *x < band.max.x - 2.0
                    // 列线从**带里**(表头行那一段,y.min = 带顶 + 3)往下长到本表可视区底
                    // (实测行情带 14 根都是 y 32.0..268.0);格与格之间的分隔条从面板顶
                    // 或从别的表的表头往下长(y.min 270 / 310 / 600),被这道 y 闸挡掉。
                    && y.min >= band.min.y - 2.0
                    && y.min <= band.max.y + 2.0
                    && y.max > band.max.y + 20.0
            })
            .count();
        out.push((pinned_band_identity(band).to_string(), rows, cols));
    }
    out
}

/// s75(0.4.1 五期 BD-UI-58 立,六期 BD-UI-59 重钉 + 收紧):表格层(pinned_table 家族)
/// 每一张**有数据的表**都必须既有行线又有列线。
/// 五期改前实测:行线只有合约表有(旧 `GridLines::Grid` 一开关只管它);列线只有合约表 +
/// 日志表 + 开了右键开关的成交表有,委托/持仓/资金/行情一张都没有 → 形制不统一。
///
/// 锚点(六期「空态提示词撤除」裁定后,旧锚点「空态那一行的文字」没了):四张数据表都以
/// 「代码」打头(TICK/ORDER/TRADE/POS_HEADERS[0]),资金表以「账号」打头。只取首列:库把
/// 视口外的表头列剔掉(实测委托表 17 列只画到「成交均价」),首列永远在场。带 = 包住表头
/// 文字的那块 BG4 矩形(`pinned_table_impl` 画的),带身份由带的几何位置定(行情带通窗宽、
/// 菜单条之下,数据区 2×2)。
///
/// 六期审计收紧两处:① 每张贴 **2 行**、行线下限 ≥2(1 行时「≥1 根」会被带底下混着的
/// 格边框 / 滚动条线蒙过去);② 列线下限从 3~8 提到 4~10(原来远低于实测,少画七八根
/// 列线都不会红)。空态那一拍另有 s77 钉。
#[test]
fn s75_every_pinned_table_paints_grid_lines() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = Arc::new(UiShared::new());
    // 这一钉问的是「有数据的表有没有网格线」——空态(0 行)本来就没有行线可画(六期口径)。
    shared.update_tick(&tick(
        ek_data::constant::Exchange::SHFE,
        "rb2605",
        "螺纹钢",
        3700.0,
        1.2,
    ));
    shared.update_tick(&tick(
        ek_data::constant::Exchange::SHFE,
        "rb2606",
        "螺纹钢2606",
        3710.0,
        -0.4,
    ));
    let order = ek_data::order::OrderData {
        gateway_name: "ctp".to_string(),
        symbol: "rb2605".to_string(),
        exchange: ek_data::constant::Exchange::SHFE,
        orderid: "GRID_1".to_string(),
        direction: Some(ek_data::constant::Direction::LONG),
        offset: ek_data::constant::Offset::OPEN,
        price: 3700.0,
        volume: 3.0,
        traded: 1.0,
        traded_price: 3700.0,
        status: ek_data::constant::Status::PARTTRADED,
        ..ek_data::order::OrderData::default()
    };
    // 每张贴 **2 行**:行线判据的下限从此能数得出来(1 行时带底下混着的格边框/滚动条线
    // 也会被抓进 y 窗口,「≥1 根行线」会被杂线蒙过去 —— 六期审计实查到的口径漏洞)。
    let trade = ek_data::trade::TradeData {
        gateway_name: "ctp".to_string(),
        symbol: "rb2605".to_string(),
        exchange: ek_data::constant::Exchange::SHFE,
        orderid: "GRID_1".to_string(),
        tradeid: "GRID_T1".to_string(),
        direction: Some(ek_data::constant::Direction::LONG),
        offset: ek_data::constant::Offset::OPEN,
        price: 3700.0,
        volume: 1.0,
        datetime: Some(36_000_000_000_000),
        ..ek_data::trade::TradeData::default()
    };
    let pos = ek_data::position::PositionData {
        gateway_name: "ctp".to_string(),
        symbol: "rb2605".to_string(),
        exchange: ek_data::constant::Exchange::SHFE,
        direction: ek_data::constant::Direction::LONG,
        volume: 3.0,
        avg_price: 3700.0,
        ..ek_data::position::PositionData::default()
    };
    shared.seed_trade_snap(ek_ui::state::TradeSnap {
        orders: vec![
            order.clone(),
            ek_data::order::OrderData {
                orderid: "GRID_2".to_string(),
                ..order.clone()
            },
        ],
        trades: vec![
            trade.clone(),
            ek_data::trade::TradeData {
                tradeid: "GRID_T2".to_string(),
                price: 3701.0,
                volume: 2.0,
                ..trade.clone()
            },
        ],
        positions: vec![
            pos.clone(),
            ek_data::position::PositionData {
                symbol: "rb2606".to_string(),
                direction: ek_data::constant::Direction::SHORT,
                volume: 2.0,
                avg_price: 3710.0,
                ..pos.clone()
            },
        ],
        accounts: vec![
            ek_data::account::AccountData {
                gateway_name: "ctp".to_string(),
                accountid: "278153".to_string(),
                balance: 1_000_000.0,
                frozen: 12_345.0,
            },
            ek_data::account::AccountData {
                gateway_name: "ctp2".to_string(),
                accountid: "278154".to_string(),
                balance: 2_000_000.0,
                frozen: 543.0,
            },
        ],
    });
    let counts = pinned_grid_line_counts(&shared);
    for (why, _) in PINNED_GRID_TARGETS {
        let (_, rows, cols) = counts
            .iter()
            .find(|(w, _, _)| w == why)
            .unwrap_or_else(|| panic!("s75:{why} 没被找到(带分类:{counts:?})"))
            .clone();
        println!("s75 {why}:行线 {rows} 根 / 列线 {cols} 根");
        assert!(
            rows >= 2,
            "s75:{why} 喂了两行数据就必须有行线,实测 {rows} 根"
        );
        assert!(
            cols == 0,
            "s75:{why} 表内不该再有列线,实测 {cols} 根 —— 0.4.1 七期 BD-UI-60 裁定「所有列分割线都去掉,只要行的分割线」(反向钉,任意色计数,换颜色不算过)",
        );
    }
}

/// s76(0.4.1 五期 BD-UI-58 立,六期 BD-UI-59 重钉 + 收紧):短表层(`egui::Grid` +
/// `header_band`:运维窗插件表 / 服务目录 / 账户面板账户清单)与表格层吃同一套网格 ——
/// 每行一根行线、每两列一根列线。改前实测:这三张表只有表头带下边那一根线。
///
/// 六期收紧三处(都是审计实查到的口径漏洞):
/// ① **一次只开一个窗**:kittest 里弹窗位置会互相重叠(实查:账户清单的带 566..1286×403..425
///    与插件表的带 87..727×402..424 在 y 上叠住)→ 「哪条带是这张表的」变成猜。分开建构
///    之后带身份唯一。
/// ② 带身份要**同一条带里含这张表的多个独有表头**(插件表「版本」+「统计」、账户清单
///    「别名」+「行情源」、服务目录三个「实例」列头):单表头锚点实查被窗口重叠骗到隔壁带
///    (「别名」被认成插件表的带);而服务目录的「服务」在运维窗里**也是一个小节标题**
///    (render.rs `section_title(ui, "服务")`)→ 那个词不能当锚点。
/// ③ 每张贴 ≥2 行、行线下限 ≥2(1 行时「≥1 根」会被带底下混着的格边框 / 滚动条线蒙过去);
///    列线下限 = **列数 − 1**(内列线根数:插件表 / 服务目录 6 列 → 5,账户清单 7 列 → 6)。
///    实测:插件表 行线 4 / 列线 5,服务目录 4 / 14(带里还捞到窗内其它竖线,判据是「≥」所以
///    不追究多出来的),账户清单 2 / 6。
#[test]
fn s76_short_tables_get_the_same_grid() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    for (open_ops, open_accounts, head, head_count, mate, why, _) in [
        (
            true,
            false,
            "版本",
            1,
            Some("统计"),
            "运维窗插件表(6 列)",
            5,
        ),
        // 服务目录的表头只有「服务 / 实例」两个词,而「服务」在运维窗里**也是一个小节标题**
        // (render.rs `section_title(ui, "服务")`)→ 不能拿它当锚点。改用「三个「实例」表头
        // 必须落在同一条带里」定带身份。
        (true, false, "实例", 3, None, "运维窗服务目录(6 列)", 5),
        (
            false,
            true,
            "别名",
            1,
            Some("行情源"),
            "账户面板账户清单(7 列)",
            6,
        ),
    ] {
        let shared = Arc::new(UiShared::new());
        shared.set_ops_window_open(open_ops);
        shared.set_accounts_window_open(open_accounts);
        if open_ops {
            // 插件表 4 行(demo_rows);服务目录 4 个实例 → flat 8 项 → 2 行。
            feed_snapshot(
                &shared,
                vec![
                    (
                        "svctl".to_string(),
                        vec!["s1".to_string(), "s2".to_string()],
                    ),
                    ("dm".to_string(), vec!["d1".to_string(), "d2".to_string()]),
                ],
            );
        } else {
            seed_md_source(&shared, "9999", "220380");
            seed_md_source(&shared, "9998", "220381");
        }
        let mut harness = harness_for(&shared);
        for _ in 0..4 {
            harness.run();
        }
        let shapes = shapes_of(&harness);
        // 0.8.2:行线走 `BORDER_SOFT`(参考站 td 那支);表头带下边线仍是 BORDER。
        let border = ek_ui::tokens::shadcn::BORDER_SOFT;
        let bands = header_bands(&shapes, ek_ui::tokens::shadcn::BG4, 60.0);
        let hl = hlines(&shapes, border);
        // 列线计数取任意色(BD-UI-60 反向钉)。
        let vl = vlines_any(&shapes);
        let rects_of = |label: &str| -> Vec<egui::Rect> {
            harness
                .query_all_by_label(label)
                .map(|n| n.rect())
                .collect()
        };
        let head_rects = rects_of(head);
        assert!(
            head_rects.len() >= head_count,
            "s76:{why}的表头「{head}」应有 {head_count} 个,实测 {} 个(s73 同口径)",
            head_rects.len()
        );
        let mate_rects = mate.map(rects_of).unwrap_or_default();
        let inside = |b: &egui::Rect, r: &egui::Rect| {
            b.min.x <= r.min.x + 2.0
                && b.max.x >= r.max.x - 2.0
                && b.min.y <= r.min.y + 2.0
                && b.max.y >= r.max.y - 2.0
        };
        let Some(band) = bands.iter().find(|b| {
            head_rects.iter().filter(|r| inside(b, r)).count() >= head_count
                && (mate_rects.is_empty() || mate_rects.iter().any(|r| inside(b, r)))
        }) else {
            panic!(
                "s76:{why}必须有一条带同时包住 {head_count} 个「{head}」{head_rects:?}(与 {:?} 同带),候选带 {bands:?}",
                mate.unwrap_or(head)
            );
        };
        let rows = hl
            .iter()
            .filter(|(y, x)| {
                *y > band.max.y + 1.0 && *y <= band.max.y + 130.0 && x.span() >= band.width() * 0.7
            })
            .count();
        let cols = vl
            .iter()
            .filter(|(x, y, _)| {
                *x > band.min.x + 2.0
                    && *x < band.max.x - 2.0
                    && y.min >= band.min.y - 2.0
                    && y.min <= band.min.y + 2.0
                    && y.max > band.max.y + 10.0
            })
            .count();
        println!(
            "s76 {why}:行线 {rows} 根 / 列线 {cols} 根(带 {:.1}..{:.1})",
            band.min.x, band.max.x
        );
        assert!(
            rows >= 2,
            "s76:{why} 喂了两行以上就必须有行线,实测 {rows} 根"
        );
        assert!(
            cols == 0,
            "s76:{why} 表内不该再有列线,实测 {cols} 根 —— BD-UI-60 裁定撤列线(反向钉,任意色)"
        );
    }
}

/// s77(0.4.1 六期 BD-UI-59 立「空态也有列线」,七期 BD-UI-60 **反向重钉**):空态(0 行)
/// 那一拍表内**也不许有列线** —— 用户裁定「所有列分割线都去掉,只要行的分割线」不挑数据。
/// 计数走任意色(`vlines_any`):把描边换个颜色不能算通过。
/// 这一拍**不数行线**:0 行没有行底可画,而带底下那条缝里混着格边框与滚动条线(实测委托 /
/// 成交空态也能数到 2 根横线)—— 数它 = 判据自己不稳。行线归 s75(喂数据那一拍)。
#[test]
fn s77_empty_tables_have_no_column_lines() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let counts = pinned_grid_line_counts(&UiShared::new());
    for (why, _) in PINNED_GRID_TARGETS {
        let (_, _rows, cols) = counts
            .iter()
            .find(|(w, _, _)| w == why)
            .unwrap_or_else(|| panic!("s77:{why} 没被找到(带分类:{counts:?})"))
            .clone();
        println!("s77 空态 {why}:列线 {cols} 根");
        assert!(
            cols == 0,
            "s77:{why} 空态(0 行)表内不该有列线,实测 {cols} 根 —— BD-UI-60 裁定撤列线",
        );
    }
}

/// s78(0.4.1 七期 BD-UI-60 新增):三条裁定各钉一颗。
///
/// - **② 表宽 = 所在区域 100%**:补宽之后「Σ列宽 ≥ 目标宽 9 成」。读口 =
///   `render::table_fill_probe`(目标宽 = 区域可用宽 − 这张表自己的滚动条占位)。
///   为什么不走形状:列线撤除后列边界在绘制指令里没有落点了,只能读状态。
/// - **④ 滚动条**:全局 `spacing.scroll` = 5 px 细 + `foreground_color` 关(把手取
///   `widgets.inactive.bg_fill` = BG4 `#262626`,不再取 `fg_stroke` = TEXT1 `#FAFAFA`
///   那支最亮色)+ 占位不悬浮(Qt `QScrollBar` 同口径,不覆盖内容)。
/// - **⑤ 表头文字上下居中**:带中心 vs 表头文字视觉矩形中心 ≤ 2 px,表格层与短表层各钉一张。
///   改前实测:表格层上隙 11 / 下隙 4(偏下),短表层上隙 3 / 下隙 10(偏上)—— 两头都不居中。
#[test]
fn s78_region_fill_thin_scrollbars_and_centered_text() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = Arc::new(UiShared::new());
    shared.update_tick(&tick(
        ek_data::constant::Exchange::SHFE,
        "rb2605",
        "螺纹钢",
        3700.0,
        1.2,
    ));
    shared.seed_trade_snap(ek_ui::state::TradeSnap {
        orders: vec![ek_data::order::OrderData {
            gateway_name: "ctp".to_string(),
            symbol: "rb2605".to_string(),
            exchange: ek_data::constant::Exchange::SHFE,
            orderid: "CTP_7801".to_string(),
            direction: Some(ek_data::constant::Direction::LONG),
            offset: ek_data::constant::Offset::OPEN,
            price: 3700.0,
            volume: 3.0,
            traded: 1.0,
            traded_price: 3700.0,
            status: ek_data::constant::Status::PARTTRADED,
            ..ek_data::order::OrderData::default()
        }],
        trades: vec![trade_row("7802", 3701.0, "螺纹钢")],
        positions: vec![ek_data::position::PositionData {
            gateway_name: "ctp".to_string(),
            symbol: "rb2605".to_string(),
            exchange: ek_data::constant::Exchange::SHFE,
            direction: ek_data::constant::Direction::LONG,
            volume: 3.0,
            avg_price: 3700.0,
            ..ek_data::position::PositionData::default()
        }],
        accounts: vec![ek_data::account::AccountData {
            gateway_name: "ctp".to_string(),
            accountid: "278153".to_string(),
            balance: 1_000_000.0,
            frozen: 12_345.0,
        }],
    });
    let mut harness = harness_for(&shared);
    for _ in 0..4 {
        harness.run();
    }

    // ② 表宽 = 区域 100%。
    for why in ["order_grid", "trade_grid", "pos_grid"] {
        let (stored, target) = ek_ui::render::table_fill_probe(&harness.ctx, why);
        assert!(
            target > 100.0,
            "s78:{why} 补宽目标宽没记上(实测 {target:.1})—— `table_fill` 状态钉没写?"
        );
        assert!(
            stored >= target * 0.9,
            "s78:{why} 列宽总和 {stored:.0} 应填到目标宽 {target:.0} 的 9 成(BD-UI-60:表宽 = 所在区域 100%,剩余补给最后一列)",
        );
    }

    // ④ 滚动条形态。
    let sc = harness.ctx.style().spacing.scroll;
    assert!(
        (sc.bar_width - ek_ui::tokens::SCROLL_BAR_WIDTH).abs() < 0.01
            && (sc.bar_width - 5.0).abs() < 0.01,
        "s78 滚动条粗细应是 5 px(BD-UI-60「尽可能细一点」),实测 {:.1}",
        sc.bar_width
    );
    assert!(
        !sc.foreground_color,
        "s78 滚动条把手不该取 `fg_stroke`(TEXT1 `#FAFAFA`,全调色板最亮的一支)—— BD-UI-60「暗一些」"
    );
    assert!(
        !sc.floating,
        "s78 滚动条要占位不悬浮(Qt QScrollBar 同口径),实测 floating = {:?}",
        sc.floating
    );

    // ⑤ 表头居中(表格层:行情带那张 14 列表)。
    let shapes = shapes_of(&harness);
    let bands = header_bands(&shapes, ek_ui::tokens::shadcn::BG4, 100.0);
    let heads = texts_containing(&shapes, "代码");
    let mut pinned = 0usize;
    for (_, rect, _) in &heads {
        let Some(band) = bands.iter().find(|b| b.contains_rect(*rect)) else {
            continue;
        };
        pinned += 1;
        let off = rect.center().y - band.center().y;
        assert!(
            off.abs() <= 2.0,
            "s78 表格层表头文字必须在带里上下居中,实测上隙 {:.1} / 下隙 {:.1}(带 {band:?} 文字 {rect:?})",
            rect.min.y - band.min.y,
            band.max.y - rect.max.y,
        );
    }
    assert!(
        pinned >= 3,
        "s78 至少要有 3 张表格层的表能测表头居中,实测 {pinned}"
    );

    // ⑤ 表头居中(短表层:运维窗插件表)。
    let ops = Arc::new(UiShared::new());
    ops.set_ops_window_open(true);
    feed_snapshot(&ops, vec![("svctl".to_string(), vec!["s1".to_string()])]);
    let mut h2 = harness_for(&ops);
    for _ in 0..4 {
        h2.run();
    }
    let shapes2 = shapes_of(&h2);
    let bands2 = header_bands(&shapes2, ek_ui::tokens::shadcn::BG4, 60.0);
    let mut short = 0usize;
    for (_, rect, _) in texts_containing(&shapes2, "版本") {
        let Some(band) = bands2.iter().find(|b| b.contains_rect(rect)) else {
            continue;
        };
        short += 1;
        let off = rect.center().y - band.center().y;
        assert!(
            off.abs() <= 2.0,
            "s78 短表层表头文字必须在带里上下居中,实测上隙 {:.1} / 下隙 {:.1}(带 {band:?} 文字 {rect:?})",
            rect.min.y - band.min.y,
            band.max.y - rect.max.y,
        );
    }
    assert!(
        short >= 1,
        "s78 运维窗插件表的表头「版本」没找到,测不到短表层居中"
    );
}

/// s79(0.4.1 八期 BD-UI-61 新增):用户问「所有表表头的字体大小都一样吗?表头的高度都一样吗?
/// 好像菜单里的表头高度不一样」—— 探针实测确认:字号本来就一致(全表 Small 14),
/// **带高不一致**:表格层 29.0 / 短表层(`Grid` + `header_band`)22.0,差 7 px。
/// 这一钉两头都钉死:
/// - 所有表头带高 = 表格层那一档(`head_h 26 + clip_rect_margin 3` = 29),带宽内极差 ≤ 1 px;
/// - 所有表头文字字号 = `TextStyle::Small`,且文字在带里上下居中(±2 px)。
///
/// 带身份靠 BG4 实心矩形 + 高度闸(横向滚动条把手也是 BG4、5 px 高,按高度挡掉)。
#[test]
fn s79_all_table_headers_same_height_and_font() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = Arc::new(UiShared::new());
    shared.update_tick(&tick(
        ek_data::constant::Exchange::SHFE,
        "rb2605",
        "螺纹钢",
        3700.0,
        1.2,
    ));
    shared.seed_trade_snap(ek_ui::state::TradeSnap {
        orders: vec![ek_data::order::OrderData {
            gateway_name: "ctp".to_string(),
            symbol: "rb2605".to_string(),
            exchange: ek_data::constant::Exchange::SHFE,
            orderid: "CTP_7901".to_string(),
            direction: Some(ek_data::constant::Direction::LONG),
            offset: ek_data::constant::Offset::OPEN,
            price: 3700.0,
            volume: 3.0,
            traded: 1.0,
            traded_price: 3700.0,
            status: ek_data::constant::Status::PARTTRADED,
            ..ek_data::order::OrderData::default()
        }],
        trades: vec![trade_row("7902", 3701.0, "螺纹钢")],
        positions: vec![ek_data::position::PositionData {
            gateway_name: "ctp".to_string(),
            symbol: "rb2605".to_string(),
            exchange: ek_data::constant::Exchange::SHFE,
            direction: ek_data::constant::Direction::LONG,
            volume: 3.0,
            avg_price: 3700.0,
            ..ek_data::position::PositionData::default()
        }],
        accounts: vec![ek_data::account::AccountData {
            gateway_name: "ctp".to_string(),
            accountid: "278153".to_string(),
            balance: 1_000_000.0,
            frozen: 12_345.0,
        }],
    });
    shared.update_contract(&contract(
        ek_data::constant::Exchange::SHFE,
        "rb2605",
        "螺纹钢2605",
    ));
    shared.set_ops_window_open(true);
    shared.set_accounts_window_open(true);
    shared.set_contracts_window_open(true);
    let mut harness = harness_for(&shared);
    for _ in 0..4 {
        harness.run();
    }
    let shapes = shapes_of(&harness);
    let small = harness.ctx.style().text_styles[&egui::TextStyle::Small].size;

    // 带高:BG4 实心矩形 + 高度闸 ≥ 20(5 px 高的滚动条把手挡掉)。
    let mut bands = header_bands(&shapes, ek_ui::tokens::shadcn::BG4, 60.0)
        .into_iter()
        .filter(|r| r.height() >= 20.0)
        .collect::<Vec<_>>();
    bands.sort_by(|a, c| (a.min.y, a.min.x).partial_cmp(&(c.min.y, c.min.x)).unwrap());
    assert!(
        bands.len() >= 9,
        "s79 至少要数到 9 块表头带(主窗 5 + 合约窗 1 + 短表 3),实测 {} 块:{:?}",
        bands.len(),
        bands
    );
    let hs: Vec<f32> = bands.iter().map(|b| b.height()).collect();
    let lo = hs.iter().copied().fold(f32::INFINITY, |a, b| a.min(b));
    let hi = hs.iter().copied().fold(f32::NEG_INFINITY, |a, b| a.max(b));
    let spread = hi - lo;
    println!("s79 带高:{hs:?}");
    assert!(
        spread <= 1.0,
        "s79 所有表头带高必须同一档,实测极差 {spread:.1} px(最矮 {lo:.1} 最高 {hi:.1})—— BD-UI-61 之前短表层 22.0 / 表格层 29.0",
    );
    assert!(
        (hi - 29.0).abs() <= 1.0,
        "s79 表头带高应是「表头行高 26 + clip_rect_margin 3」= 29,实测最高 {hi:.1}"
    );

    // 字号 + 带里居中:两层各自的独有表头词。
    for label in [
        "今开",
        "涨跌幅",
        "昨仓",
        "最小变动",
        "合约分类",
        "版本",
        "依赖",
        "统计",
        "实例",
        "别名",
        "行情源",
    ] {
        let mut found = 0usize;
        for cs in shapes.iter() {
            let egui::Shape::Text(t) = cs else {
                continue;
            };
            if !t.galley.text().starts_with(label) {
                continue;
            }
            let vr = t.visual_bounding_rect();
            // 带身份:kittest 里弹窗位置会互相重叠(s76 同一坑)→ 「哪条带是这行的」不能只靠
            // 包含关系,取**中心离文字最近**的那条(真带差 ~1 px,借来的带差 ~20 px)。
            let mut band: Option<&egui::Rect> = None;
            let mut best = f32::MAX;
            for b in bands.iter().filter(|b| b.contains_rect(vr)) {
                let d = (b.center().y - vr.center().y).abs();
                if d < best {
                    best = d;
                    band = Some(b);
                }
            }
            let Some(band) = band else {
                continue;
            };
            found += 1;
            let size = t
                .galley
                .job
                .sections
                .first()
                .map(|s| s.format.font_id.size)
                .unwrap_or(0.0);
            assert!(
                (size - small).abs() < 0.01,
                "s79 表头「{label}」字号 {size:.1} 应等于 Small {small:.1}(全表同一字号)",
            );
            let off = vr.center().y - band.center().y;
            assert!(
                off.abs() <= 2.0,
                "s79 表头「{label}」必须在带里上下居中,实测上隙 {:.1} / 下隙 {:.1}(带 {band:?})",
                vr.min.y - band.min.y,
                band.max.y - vr.max.y,
            );
        }
        assert!(
            found >= 1,
            "s79 表头「{label}」没在任何表头带里找到,测不到字号/高度"
        );
    }
}

/// s80(0.4.1 九期 BD-UI-62 新增):行情带 tab 条 = **交易所中文名**,并且**待在行情带里**。
/// 用户实看:「交易所的那个编码放到下面那个标签,但是现在表格被下面标签给挡住了,只有滚动
/// 才能看到…而且不要显示交易所的代码,而是显示交易所的名字」。
/// 实锤(改前 1280×860 探针):tab 标签落在 y 274..300,而数据区「委托」tab 头在 y 278..304 ——
/// 两条条带**互相压着**;改后 tab 条 y 251.9..277.9,表头带 32..61,体表首行 61..87 ✓。
#[test]
fn s80_market_band_tab_strip_names_and_stays_in_band() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = Arc::new(UiShared::new());
    feed_rows(&shared, demo_rows());
    let mut harness = harness_for(&shared);
    let hit = ek_ui::fonts::apply_cjk_fonts(&harness.ctx);
    assert!(hit.is_some(), "s80 验收环境必须有 CJK 候选字体");
    for _ in 0..4 {
        harness.run();
    }
    let shapes = shapes_of(&harness);

    // ① tab 标签 = 中文名(照 Python:`xt_gateway.py:1089-1094` /
    //    `datafeed/ak/futures_member_pos.py:14-19`),不是线上代码。
    let mut tabs: Vec<(String, egui::Rect)> = Vec::new();
    for ex in ek_ui::state::MARKET_ORDER {
        let name = ek_ui::render::exchange_tab_name(ex);
        assert!(
            !matches!(name, "SHFE" | "DCE" | "CZCE" | "CFFEX" | "GFEX" | "INE"),
            "s80 行情带 tab 名应是中文名,实测 {name:?}({})",
            ex.as_str()
        );
        let mut got: Vec<egui::Rect> = harness.query_all_by_label(name).map(|n| n.rect()).collect();
        assert!(
            !got.is_empty(),
            "s80 行情带 tab「{name}」({})缺失",
            ex.as_str()
        );
        got.sort_by_key(|r| (r.min.y as i32, r.min.x as i32));
        tabs.push((name.to_string(), got[0]));
    }

    // ② tab 条在表**之下**(表头带之下),不是压在表上。
    let mut market_bands = header_bands(&shapes, ek_ui::tokens::shadcn::BG4, 600.0)
        .into_iter()
        .filter(|r| r.min.y < 120.0)
        .collect::<Vec<_>>();
    market_bands.sort_by_key(|r| r.min.y as i32);
    assert!(
        !market_bands.is_empty(),
        "s80 找不到行情带表头带(BG4 实心、宽 ≥ 600、顶 y < 120)"
    );
    let mb = market_bands[0];
    for (name, r) in &tabs {
        assert!(
            r.min.y > mb.max.y,
            "s80 tab「{name}」应在表下:tab 顶 {:.1} 应 > 行情表头带底 {:.1}(带 {mb:?})",
            r.min.y,
            mb.max.y
        );
    }

    // ③ tab 条不得越进数据区:与数据区「委托」tab 头(x > 320 = 数据区左沿之外)不得相交。
    let heads: Vec<egui::Rect> = harness
        .query_all_by_label("委托")
        .map(|n| n.rect())
        .filter(|r| r.min.x > 320.0)
        .collect();
    assert!(
        !heads.is_empty(),
        "s80 数据区「委托」tab 头缺失(拿它当数据区上沿的锚)"
    );
    for (name, r) in &tabs {
        for h in &heads {
            assert!(
                !r.intersects(*h),
                "s80 tab「{name}」({r:?})压到数据区「委托」tab 头({h:?})—— 行情带把 tab 条挤到面板外了",
            );
        }
    }

    // ④ 标签**可点** = 换所。这条接线最容易被悄悄断掉(本轮改的就是标签文本本身):
    //    点「大商所」必须把 `selected_exchange` 切到 DCE。
    let target = tabs
        .iter()
        .find(|(n, _)| n == "大商所")
        .map(|(_, r)| *r)
        .expect("s80 缺「大商所」tab 矩形");
    assert_ne!(
        shared.selected_exchange(),
        "DCE",
        "s80 起点就不该已经在 DCE 上(否则这条钉测不出东西)"
    );
    click_at(
        &mut harness,
        target.center(),
        egui::PointerButton::Primary,
        1,
    );
    // `click_at` 只往这一拍塞事件,必须再跑一帧才被界面消费(其它钉都是这么配的)。
    harness.run();
    assert_eq!(
        shared.selected_exchange(),
        "DCE",
        "s80 点「大商所」tab 应把当前所切到 DCE(标签改名后接线断了)"
    );
}

/// s81(0.4.1 九期 BD-UI-62 新增):悬停 / 选中高亮 = **整行**,包括行尾空余段。
/// 用户裁定:「现在只是有内容的那一点选中了,但整行后面空余的没有选…我们选的是整行,
/// 包括空行的也一起给它标上颜色」。库给的行矩形只到最后一列右边(`table.rs:689-690`
/// `col_x[0]..=col_x[last]`),列总宽窄于可视区时右边就不亮。
#[test]
fn s81_row_highlight_covers_full_row_width() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = Arc::new(UiShared::new());
    feed_rows(&shared, demo_rows());
    shared.update_tick(&ek_data::tick::TickData {
        gateway_name: "ctp".to_string(),
        symbol: "rb2710".to_string(),
        exchange: ek_data::constant::Exchange::SHFE,
        datetime: 7 * 3600 * 1_000_000_000,
        name: "螺纹钢2710".to_string(),
        last_price: 3120.0,
        ..ek_data::tick::TickData::default()
    });
    let mut harness = harness_for(&shared);
    let hit = ek_ui::fonts::apply_cjk_fonts(&harness.ctx);
    assert!(hit.is_some(), "s81 验收环境必须有 CJK 候选字体");
    for _ in 0..4 {
        harness.run();
    }
    let shapes = shapes_of(&harness);
    let mut market_bands = header_bands(&shapes, ek_ui::tokens::shadcn::BG4, 600.0)
        .into_iter()
        .filter(|r| r.min.y < 120.0)
        .collect::<Vec<_>>();
    market_bands.sort_by_key(|r| r.min.y as i32);
    assert!(!market_bands.is_empty(), "s81 找不到行情带表头带(高亮锚)");
    let mb = market_bands[0];

    // 悬在**行尾空余段最右**(带右缘往左 5 px)。故意贴着右缘:实测列宽并集 Σ ≈ 1250 <
    // 带宽 1265,这个点落在「内容之外、整行之内」—— 只有当悬停判定也按整行算
    // (`rect_contains_pointer(fill)`,不是 `r`)时才会亮,正好钉住那一半裁定。
    let probe = egui::pos2(mb.max.x - 5.0, mb.max.y + 14.0);
    harness.hover_at(probe);
    harness.run();
    let shapes2 = shapes_of(&harness);
    let hov: Vec<egui::Rect> = filled_rects(&shapes2, ek_ui::tokens::shadcn::BG5)
        .into_iter()
        // 行高亮块的顶 = 表头带底(体表紧接着带底开始),所以闸是 `>=` 不是 `>`。
        .filter(|r| r.height() > 12.0 && r.height() < 60.0 && r.min.y >= mb.max.y - 1.0)
        .collect();
    assert!(
        !hov.is_empty(),
        "s81 悬停点 {probe:?} 之后没有任何行高亮块(悬停底色 = `widgets.hovered.bg_fill`)",
    );
    let widest = hov.iter().copied().fold(0.0f32, |a, r| a.max(r.width()));
    assert!(
        widest >= mb.width() - 2.0,
        "s81 整行高亮应铺满整行宽:实测最宽 {widest:.1} px,行情带宽 {:.1} px(带 {mb:?})",
        mb.width()
    );
}

/// s82(0.4.1 九期 BD-UI-62 新增):数据区那根**竖**分隔条必须贯穿整块。
/// 用户实看:「竖线拉的时候只高跳了上面委托和成交之间,持仓和资金之间那条竖着的白色跳线
/// 没有跳出来 —— 只跳了一半」。实锤(改前探针):所谓竖刀是两条独立线段
/// (上排 y 278..562、下排 y 568..852,同一个 x=798),悬哪条只亮哪条。
/// 改后(`splitters::quad`):一根贯穿线 y 278..852 ✓ 覆盖上排表头带顶到下排表头带底。
#[test]
fn s82_data_area_vertical_splitter_is_one_continuous_line() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = Arc::new(UiShared::new());
    feed_rows(&shared, demo_rows());
    let mut harness = harness_for(&shared);
    let hit = ek_ui::fonts::apply_cjk_fonts(&harness.ctx);
    assert!(hit.is_some(), "s82 验收环境必须有 CJK 候选字体");
    for _ in 0..4 {
        harness.run();
    }
    let shapes = shapes_of(&harness);
    // 数据区四块表头带(顶 y > 200 的那几块):上排两块 + 下排两块。
    let mut data_bands = header_bands(&shapes, ek_ui::tokens::shadcn::BG4, 200.0)
        .into_iter()
        .filter(|r| r.min.y > 200.0)
        .collect::<Vec<_>>();
    data_bands.sort_by(|a, b| (a.min.y, a.min.x).partial_cmp(&(b.min.y, b.min.x)).unwrap());
    assert!(
        data_bands.len() >= 4,
        "s82 数据区应有 4 块表头带(委托/成交/持仓/资金),实测 {} 块:{:?}",
        data_bands.len(),
        data_bands
    );
    let top_y = data_bands[0].min.y;
    let bottom_y = data_bands
        .iter()
        .copied()
        .fold(0.0f32, |a, r| a.max(r.max.y));
    // 竖分隔条 x = 上排两块表头带的接缝(委托带右缘 / 成交带左缘 中点)。
    let seam = (data_bands[0].max.x + data_bands[1].min.x) * 0.5;

    for (why, y) in [
        ("上排(委托|成交)", data_bands[0].center().y),
        ("下排(持仓|资金)", data_bands[3].center().y),
    ] {
        harness.hover_at(egui::pos2(seam, y));
        harness.run();
        let sh = shapes_of(&harness);
        let v: Vec<(f32, egui::Rangef, egui::Color32)> = vlines_any(&sh)
            .into_iter()
            .filter(|(_, _, c)| *c == ek_ui::tokens::shadcn::ACCENT4)
            .collect();
        assert!(
            v.iter()
                .any(|(_, r, _)| r.min <= top_y + 1.0 && r.max >= bottom_y - 1.0),
            "s82 悬在{why}的竖线上(x {seam:.1}):ACCENT4 竖线应是一根贯穿线(覆盖 y {top_y:.1}..{bottom_y:.1}),实测 {v:?}",
        );
    }
}

/// s83(0.4.1 十期 BD-UI-63 新增):TD 登录被柜台拒时,**原因直接跟着红字打在账户行上**。
/// 实连实锤:纯 TD 账号在 7×24 套走到「连接成功 → 授权验证成功 → 交易服务器登录失败,
/// 代码：3，信息：CTP:不合法的登录」,而账户行只写「已装配·登录失败」——用户只看到
/// "登不上",看不到"为什么登不上"。用户裁定:「把『TD 登录被拒 + 柜台原因』显式打到账户行」。
///
/// 判据分四层:① 状态列那一格带着短原因;② 窗下方「状态细节」那一行仍给全句(短标签是
/// 补充不是替代 —— Grid 状态列被整句挤宽会把别的列顶窄,s39 口径);③ 状态侧事实齐
/// (`login` + `login_brief`,不是文案拼出来的);④ 恢复在线后原因**不留在行上**(不给健康行添噪)。
#[test]
fn s83_account_row_shows_counter_reject_reason() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = Arc::new(UiShared::new());
    feed_rows(&shared, demo_rows());
    let (gw1, _gw2) = two_accounts(&shared);
    shared.update_account_form(
        &gw1,
        acct_form(
            "9999",
            "278153",
            "tcp://127.0.0.1:30001",
            "tcp://127.0.0.1:30011",
        ),
    );
    shared.set_accounts_window_open(true);
    let mut harness = harness_for(&shared);
    harness.run_steps(4);

    // 柜台原句照 ek-ctp `map::error_text`(`map.rs:332-333`)的形状,一字不改地喂进状态口。
    shared.note_gateway_status(
        &gw1,
        &status_of(&gw1, |st| {
            st.td_handle_up = true;
            st.td_login_failed = true;
            st.td_logged_in = false;
            st.td_last_error =
                Some("交易服务器登录失败，代码：3，信息：CTP:不合法的登录".to_string());
        }),
    );
    harness.run_steps(4);

    // ① 状态列:红字那一格现在带着柜台原因。
    assert!(
        harness
            .query_by_label_contains("已装配·登录失败·不合法的登录(3)")
            .is_some(),
        "s83 账户行状态列没带上柜台原因(应显形「已装配·登录失败·不合法的登录(3)」)"
    );
    // ② 整句全量在 status_note(0.9.10:窗下方「状态细节」段退役,取证 = status_note + 事件日志)。
    let note = shared
        .account(&gw1)
        .unwrap()
        .status_note
        .clone()
        .unwrap_or_default();
    assert!(
        note.contains("交易服务器登录失败，代码：3"),
        "s83 柜台原句(带代码)要在状态数据里给全: {note}"
    );

    // ③ 状态侧事实:短标签是 `apply_status` 从 `td_last_error` 抠出来的,不是渲染层拼的。
    let rows = shared.accounts();
    let a = rows.iter().find(|r| r.gateway == gw1).expect("行还在");
    assert_eq!(
        a.login,
        ek_ui::state::LoginState::LoginFailed,
        "s83 登录态应是「登录失败」"
    );
    assert_eq!(
        a.login_brief.as_deref(),
        Some("不合法的登录(3)"),
        "s83 短标签形状不对(应剥掉 `CTP:` 前缀并把代码括在后面)"
    );

    // ④ 恢复在线:原因不粘在行上。
    let now = ek_ctp::map::now_epoch_ms();
    shared.note_gateway_status(
        &gw1,
        &status_of(&gw1, |st| {
            st.td_handle_up = true;
            st.td_logged_in = true;
            st.td_last_login_ok_ms = Some(now - 5_000);
            st.td_last_account_ms = Some(now);
        }),
    );
    harness.run_steps(4);
    let rows = shared.accounts();
    let a = rows.iter().find(|r| r.gateway == gw1).expect("行还在");
    assert!(
        a.login_brief.is_none(),
        "s83 在线行不该带柜台原因: {:?}",
        a.login_brief
    );
    assert!(
        harness.query_by_label("已装配·在线").is_some(),
        "s83 恢复后状态列应回到「已装配·在线」(不带原因)"
    );
}

/// s71(BD-UI-42):查询合约窗的**列线**必须落在列边界上。列线原来取的是
/// 「本列表头矩形的右边 + 半间距」—— 表头文字比数据窄(「名称」2 字 vs 「螺纹钢2605」)
/// 时列线画进列里。判据:本帧绘制指令里的竖线(egui_table 画在可拖列边界上,
/// 色 = `noninteractive.bg_stroke` = `border`)必须落在相邻两列**内容矩形**之间。
/// (0.4.1 五期 BD-UI-58 起全部表都有列线,「合约窗是全仓唯一开网格线的表」这条口径退役;
/// 这一钉不变,仍是列线落位的判据。原来这里是一张带真行的快照当视觉回归,看图这条已撤除。)
#[test]
fn s71_contract_table_gridlines_land_on_column_bounds() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = Arc::new(UiShared::new());
    shared.update_contract(&contract(
        ek_data::constant::Exchange::SHFE,
        "rb2605",
        "螺纹钢2605",
    ));
    shared.update_contract(&contract(
        ek_data::constant::Exchange::DCE,
        "a2709",
        "黄玉米2709",
    ));
    shared.update_contract(&contract(
        ek_data::constant::Exchange::CZCE,
        "TA709",
        "精对苯二甲酸709",
    ));
    shared.set_contracts_window_open(true);
    let mut harness = harness_for(&shared);
    let hit = ek_ui::fonts::apply_cjk_fonts(&harness.ctx);
    assert!(hit.is_some(), "验收环境必须有 CJK 候选字体");
    harness.run();
    // 三行真数据必须在场(没有真行,列线判据退化成空表)。
    for name in ["螺纹钢2605", "黄玉米2709", "精对苯二甲酸709"] {
        assert!(
            harness.query_by_label(name).is_some(),
            "合约表必须有真行「{name}」"
        );
    }
    // 表头格:「最小变动」是全仓唯一标签 → 用它定「合约表表头那一行」;
    // 其余列名(交易所 / 名称 在主窗表里也有同名格)按同一行 y 挑,不靠查询顺序。
    let anchor = harness
        .query_by_label("最小变动")
        .expect("合约表必须有「最小变动」表头")
        .rect();
    let head_of = |label: &str| -> egui::Rect {
        harness
            .query_all_by_label(label)
            .map(|n| n.rect())
            .find(|r| (r.min.y - anchor.min.y).abs() < 2.0 && (r.max.y - anchor.max.y).abs() < 2.0)
            .unwrap_or_else(|| {
                panic!(
                    "合约表必须有「{label}」表头(与「最小变动」同一行 y={:.1})",
                    anchor.min.y
                )
            })
    };
    let heads: Vec<egui::Rect> = [
        "交易所",
        "名称",
        "合约分类",
        "乘数",
        "最小变动",
        "最小委托量",
    ]
    .iter()
    .map(|h| head_of(h))
    .collect();
    // 带 = 盖住表头行的那根 BG4 实心矩形 → 这张表的 x 边界(列线只在这里面找,
    // 免得把主窗侧栏分隔线当成合约表的列线)。
    let shapes = shapes_of(&harness);
    let band = header_bands(&shapes, ek_ui::tokens::shadcn::BG4, 100.0)
        .into_iter()
        .find(|b| b.contains_rect(anchor))
        .expect("合约表必须有表头带(BG4 实心矩形盖住表头行)");
    let name_col = head_of("名称");
    let rows: Vec<egui::Rect> = ["螺纹钢2605", "黄玉米2709", "精对苯二甲酸709"]
        .iter()
        .flat_map(|n| harness.query_all_by_label(n).map(|x| x.rect()))
        .filter(|r| {
            r.min.y > band.max.y
                && r.min.x >= name_col.min.x - 2.0
                && r.min.x <= name_col.max.x + 2.0
        })
        .collect();
    assert_eq!(
        rows.len(),
        3,
        "合约表必须正好三行真数据(都在「名称」列里),实测 {rows:?}"
    );
    let top = heads.iter().map(|r| r.min.y).fold(f32::INFINITY, f32::min);
    let bottom = rows
        .iter()
        .map(|r| r.max.y)
        .fold(f32::NEG_INFINITY, f32::max);
    // 0.4.1 七期 BD-UI-60 **反向重钉**:这张表(以及所有表)表内不得有列线。
    // 计数取任意色:把描边换个颜色不能算通过。原来这条钉的是「列线落在相邻两列之间」,
    // 列线撤除后落位判据作废,改钉「行线还在 + 列线为零」。
    let vlines: Vec<(f32, egui::Rangef, egui::Color32)> = shapes
        .iter()
        .filter_map(|s| match s {
            egui::Shape::LineSegment { points, stroke }
                if !stroke.is_empty() && (points[0].x - points[1].x).abs() < 0.5 =>
            {
                Some((
                    points[0].x,
                    egui::Rangef::new(points[0].y, points[1].y),
                    stroke.color,
                ))
            }
            _ => None,
        })
        .filter(|(x, y, _)| {
            y.span() > 10.0
                // 只算这张表里的:从表头带顶边往下长、与表体重叠的竖线。
                // 主窗分隔条也是竖线(x=798 那一刀),它的 y 段与合约表重叠,靠带 x 边界挡掉。
                && y.min >= band.min.y - 2.0
                && y.min < bottom
                && y.max > top
                && *x >= band.min.x - 2.0
                && *x <= band.max.x + 2.0
        })
        .collect();
    assert!(
        vlines.is_empty(),
        "六列合约表(0.8.5 起)表内不该有列线,实测 {} 根:{:?}",
        vlines.len(),
        vlines
    );
    // 行线还在(BD-UI-58 立、BD-UI-60 起它是唯一的网格线)。
    let row_lines = shapes
        .iter()
        .filter(|s| {
            matches!(s, egui::Shape::LineSegment { points, stroke }
            if !stroke.is_empty() && (points[0].y - points[1].y).abs() < 0.5
                && points[0].y > band.max.y && points[0].y <= bottom + 6.0
                && points[0].x >= band.min.x - 2.0 && points[1].x >= band.max.x * 0.5)
        })
        .count();
    assert!(
        row_lines >= 2,
        "合约表三行真数据必须有行线(BD-UI-60 起行线是唯一的网格线),实测 {row_lines} 根"
    );
}

// ============ 0.2.29 Wave A 判据(测试方案 T2 / T3 / T4 / T5 / T7)============
// 判据一律写在测试里,夹具写在下面;形状判据(本帧绘制指令)只在非用不可处(T5)。

/// 成交行夹具:数字列刻意不同位数(T3);成交额与价格错开,免得同串撞名。
fn trade_row(id: &str, price: f64, name: &str) -> ek_data::trade::TradeData {
    ek_data::trade::TradeData {
        gateway_name: "ctp".to_string(),
        symbol: "rb2605".to_string(),
        name: name.to_string(),
        exchange: ek_data::constant::Exchange::SHFE,
        orderid: format!("CTP_{id}"),
        tradeid: id.to_string(),
        direction: Some(ek_data::constant::Direction::LONG),
        offset: ek_data::constant::Offset::OPEN,
        price,
        volume: 1.0,
        traded_amount: price * 2.0,
        datetime: Some(36_000_000_000_000),
        ..ek_data::trade::TradeData::default()
    }
}

fn trades_snap(trades: Vec<ek_data::trade::TradeData>) -> ek_ui::state::TradeSnap {
    ek_ui::state::TradeSnap {
        orders: Vec::new(),
        trades,
        positions: Vec::new(),
        accounts: Vec::new(),
    }
}

/// T2 列宽按内容(毛病 2):同一张合约表,名称列喂短名 vs 长名,下一列(「乘数」)
/// 表头的左边界必须随内容右移;长名文字不得越过那条列线。
#[test]
fn t2_column_width_follows_content() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let probe = |name: &str| -> (f32, f32) {
        let shared = Arc::new(UiShared::new());
        feed_rows(&shared, demo_rows());
        shared.update_contract(&contract(ek_data::constant::Exchange::SHFE, "rb2605", name));
        shared.set_contracts_window_open(true);
        let mut harness = harness_for(&shared);
        let hit = ek_ui::fonts::apply_cjk_fonts(&harness.ctx);
        assert!(hit.is_some(), "验收环境必须有 CJK 候选字体");
        harness.run();
        let head = harness
            .query_by_label("乘数")
            .unwrap_or_else(|| panic!("合约表必须有「乘数」表头"))
            .rect();
        let cell = harness
            .query_by_label(name)
            .unwrap_or_else(|| panic!("合约表必须有名称格「{name}」"))
            .rect();
        (head.min.x, cell.max.x)
    };
    let (a_head, a_cell) = probe("螺纹");
    let (b_head, b_cell) = probe("精对苯二甲酸709");
    assert!(
        a_cell <= a_head + 1.0,
        "短名文字也不得越过下一列左边界:文字右 {a_cell:.1} vs 列线 {a_head:.1}"
    );
    assert!(
        b_head > a_head + 20.0,
        "名称列宽必须随内容变:短名下一列 x={a_head:.1} → 长名下一列 x={b_head:.1}"
    );
    assert!(
        b_cell <= b_head + 1.0,
        "长名文字不得越过下一列左边界(截断/重叠):文字右 {b_cell:.1} vs 列线 {b_head:.1}"
    );
}

/// T3 数字成列(毛病 3 + 毛病 6)。裁定链:0.2.x 的处置 = **右对齐**(六张表 35 个右对齐格位经
/// `RIGHT_COLS` 出);**0.8.0 裁定 D = 全部左对齐** → 右对齐那半退役,这一条**按方案白名单
/// 改向**为:同列每行数字**左边界同 x(±1 px)** **且**数字格走**等宽**字体(`tokens::num_text`)。
///
/// 明码写在这里的代价(方案 §5 R7):`format::price` 剥尾零(`101.0→"101"`、`99.7`、`12345.678`),
/// 宽度天生不等 → 左对齐下**小数点不在同一竖线**上;等宽只保「字符宽度一致、位数可数」。
/// 本钉因此钉左沿 + 等宽,**不钉右沿**(旧钉钉右沿的机制已撤,留着就是假判据)。
#[test]
fn t3_numeric_columns_are_left_aligned_and_monospace() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = Arc::new(UiShared::new());
    feed_rows(&shared, demo_rows());
    shared.seed_trade_snap(trades_snap(vec![
        trade_row("P1", 1.25, "螺纹"),
        trade_row("P2", 12345.678, "螺纹"),
        trade_row("P3", 99.7, "螺纹"),
    ]));
    // 行情带三行:最新价位数刻意差很多(5.0 / 12345.0 / 98.0)→ 买1价 / 卖1价 列宽由最宽那行
    // 决定;全左对齐后三行的**左边界**必须落在同一条竖线上。
    shared.update_tick(&tick(
        ek_data::constant::Exchange::SHFE,
        "rb2605",
        "螺纹钢2605",
        5.0,
        1.0,
    ));
    shared.update_tick(&tick(
        ek_data::constant::Exchange::SHFE,
        "cu2709",
        "铜2709",
        12345.0,
        2.0,
    ));
    shared.update_tick(&tick(
        ek_data::constant::Exchange::SHFE,
        "au2612",
        "黄金2612",
        98.0,
        3.0,
    ));
    let mut harness = harness_for(&shared);
    let hit = ek_ui::fonts::apply_cjk_fonts(&harness.ctx);
    assert!(hit.is_some(), "验收环境必须有 CJK 候选字体");
    harness.run();
    let left_of = |s: &str| {
        harness
            .query_by_label(s)
            .unwrap_or_else(|| panic!("必须有数字格「{s}」"))
            .rect()
            .min
            .x
    };
    let spread = |vals: &[f32]| {
        let lo = vals.iter().copied().fold(f32::INFINITY, f32::min);
        let hi = vals.iter().copied().fold(f32::NEG_INFINITY, f32::max);
        hi - lo
    };
    let trades = [left_of("1.25"), left_of("12345.678"), left_of("99.7")];
    assert!(
        spread(&trades) <= 1.0,
        "成交表价格列每行**左边界**必须对齐(全左对齐),实测 {trades:?}"
    );
    // 盘口:fixture 里 bid = last - 0.5,ask = last + 0.5。
    let bid = [left_of("4.5"), left_of("12344.5"), left_of("97.5")];
    let ask = [left_of("5.5"), left_of("12345.5"), left_of("98.5")];
    assert!(
        spread(&bid) <= 1.0,
        "行情带「买1价」列必须左沿成列(毛病 6 由三列小表 + 等宽守),实测 {bid:?}"
    );
    assert!(
        spread(&ask) <= 1.0,
        "行情带「卖1价」列必须左沿成列(毛病 6 由三列小表 + 等宽守),实测 {ask:?}"
    );
    // 等宽钉:撤了右对齐之后,「成列」全靠等宽这一条(整串等于该数字的文字形状必须等宽)。
    for s in [
        "1.25",
        "12345.678",
        "99.7",
        "4.5",
        "12344.5",
        "5.5",
        "12345.5",
    ] {
        let at = harness
            .query_by_label(s)
            .unwrap_or_else(|| panic!("必须有数字格「{s}」"))
            .rect();
        assert!(
            monospace_at(&harness, s, &at)
                .unwrap_or_else(|| { panic!("本帧必须有数字格「{s}」的文字形状") }),
            "数字格「{s}」必须走等宽字体(tokens::num_text)"
        );
    }
}

/// T4 成交表横向可滚(毛病 5「最后一列被右缘切掉且到不了」):12 列 + 长名称 →
/// 列总宽 > 成交格可用宽。判据 = 在成交表上滚一下,首列表头必须横移,
/// 且 y 不动(固定表头不回归)。
#[test]
fn t4_trades_table_scrolls_horizontally() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = Arc::new(UiShared::new());
    feed_rows(&shared, demo_rows());
    shared.seed_trade_snap(trades_snap(
        (1..=6)
            .map(|i| trade_row(&format!("T{i}"), 102.5 + i as f64, "螺纹钢2605螺纹钢2605"))
            .collect(),
    ));
    let mut harness = harness_for(&shared);
    let hit = ek_ui::fonts::apply_cjk_fonts(&harness.ctx);
    assert!(hit.is_some(), "验收环境必须有 CJK 候选字体");
    harness.run();
    // 0.3.3 Wave F:锚点从「成交号」换成「成交金额」——列序照 Python 后「成交号」在第 10 列,
    // 落在横向裁剪之外(悬停在裁剪外的位置 = 滚轮不被受理,实测 x 不动)。
    let before = harness
        .query_by_label("成交金额")
        .unwrap_or_else(|| panic!("成交表必须有「成交金额」表头"))
        .rect();
    // 滚轮只受理「指针在滚动区空白/体表处」的位置:实测悬停在**表头格**上不动
    // (x 不变),悬停在体表区(表头下方)与右侧空白都能滚 —— 判据取能滚的位置。
    // 悬停点必须落在**可视区内**:夹具名称很长,名称列(第 2 列)一定在左边可见处,
    // 而「成交金额」那一列已被裁到可视区外 —— 悬停在裁剪外滚轮不受理。
    let hover_x = harness
        .query_all_by_label_contains("螺纹钢2605螺纹钢2605")
        .next()
        .expect("T4:成交表名称格必须查得到")
        .rect()
        .center()
        .x;
    let hover_pt = egui::pos2(hover_x, before.max.y + 40.0);
    harness.hover_at(hover_pt);
    harness.step();
    // 实测:harness 里滚动区「确认悬停」要一拍,滚轮 delta 未被消费时留到下一拍
    // (单发一次滚轮 = x 不动;连发两次 = 第二拍被受理)。真实窗口里连续滚轮
    // 天然就是多拍,这里照那个形状喂。
    for _ in 0..4 {
        harness.event(egui::Event::MouseWheel {
            unit: egui::MouseWheelUnit::Point,
            // 负 x = 内容左移 → 露出右边被切掉的列(最后一列可达性)。
            // 0.4.0:成交格从「右下 2×2」变成「右半上格」,格宽变化 → 多滚两拍才到底。
            delta: egui::vec2(-260.0, 0.0),
            modifiers: egui::Modifiers::NONE,
        });
        harness.step();
    }
    let after = harness
        .query_by_label("成交金额")
        .unwrap_or_else(|| panic!("滚动后「成交金额」表头必须还在"))
        .rect();
    assert!(
        (after.min.x - before.min.x).abs() > 100.0,
        "成交表必须能横向滚动(列总宽 > 格宽,最后一列才可达):前 x={:.1} 后 x={:.1}",
        before.min.x,
        after.min.x
    );
    assert!(
        (after.min.y - before.min.y).abs() < 1.0,
        "横向滚动不得把表头推走(固定表头不回归):前 y={:.1} 后 y={:.1}",
        before.min.y,
        after.min.y
    );
    // 可达性:滚动后成交表的「接口」列(最后一列)必须落进可视区(画布宽 1280)。
    let last = harness
        .query_all_by_label("接口")
        .map(|n| n.rect())
        .find(|r| (r.min.y - before.min.y).abs() < 2.0)
        .unwrap_or_else(|| panic!("滚动后成交表必须有「接口」列表头"));
    assert!(
        last.max.x <= 1280.0,
        "滚动后最后一列必须进可视区:接口列右缘 x={:.1}",
        last.max.x
    );
}

/// T5 斑马跟主题开关(不硬开):唯一主题(Nova)= `striped:false`。
/// 三层判据:① `visuals.striped == false`(主题口径);② 渲染侧不许有斑马开关 ——
/// BD-UI-55 换 egui_table 之后这条换了写法:egui_table 0.7.0 里根本没有 striped /
/// faint_bg_color 这条路(全库扫过零命中),行底色只剩「选中 = 主题 `selection.bg_fill`、
/// hover = `widgets.hovered.bg_fill`」一条(row_ui),旧 TableBuilder 的
/// `.striped(striped)` 透传随库一起退役;③ 这一帧的绘制指令里不许出现任何斑马块
/// (斑马 = `faint_bg_color` 实心矩形 = 我们的 BG2),一处都不该有。
/// (原来这条是在每行右侧取一个像素比颜色。)
#[test]
fn t5_row_backgrounds_do_not_alternate() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = Arc::new(UiShared::new());
    feed_rows(&shared, demo_rows());
    // 一行长名把名称列撑开 → 短名行的名称格右半是空白(空白处正是斑马会露出来的地方)。
    shared.update_contract(&contract(
        ek_data::constant::Exchange::CZCE,
        "TA709",
        "精对苯二甲酸709",
    ));
    let shorts: Vec<String> = (1..=6).map(|i| format!("螺{i}")).collect();
    for (i, n) in shorts.iter().enumerate() {
        shared.update_contract(&contract(
            ek_data::constant::Exchange::SHFE,
            &format!("rb26{i:02}"),
            n,
        ));
    }
    shared.set_contracts_window_open(true);
    let mut harness = harness_for(&shared);
    let hit = ek_ui::fonts::apply_cjk_fonts(&harness.ctx);
    assert!(hit.is_some(), "验收环境必须有 CJK 候选字体");
    harness.run();
    // ① 主题口径。
    assert!(
        !harness.ctx.style().visuals.striped,
        "唯一主题的 `visuals.striped` 必须是 false(Nova 表没有斑马纹)"
    );
    // ② 渲染侧口径(BD-UI-55 换库后写法变了,判据的语义没变:斑马不硬开)。
    let render_src = std::fs::read_to_string(concat!(env!("CARGO_MANIFEST_DIR"), "/src/render.rs"))
        .expect("render.rs 必须可读");
    assert!(
        render_src.contains("visuals().selection.bg_fill") && !render_src.contains(".striped("),
        "行底色只许走主题(选中 `selection.bg_fill` / hover `widgets.hovered.bg_fill`),\
         渲染侧不得残留 TableBuilder 的 `.striped(...)` 透传 —— egui_table 没有这条路",
    );
    // ③ 六行都在场,且整帧没有一处 BG2 斑马块。
    for n in &shorts {
        assert!(harness.query_by_label(n).is_some(), "合约表必须有行「{n}」");
    }
    let stripes = filled_rects(&shapes_of(&harness), ek_ui::tokens::shadcn::BG2);
    assert!(
        stripes.is_empty(),
        "本帧不许出现斑马块(faint_bg_color = BG2 实心矩形),实测 {} 块:{:?}",
        stripes.len(),
        stripes
    );
}

/// T7 行数 × 虚拟滚动钉(BD-UI-55 换库,口径变更,理由如下)。
///
/// **口径为什么变**:egui_table 的体表按视口剔除行 —— `region_ui` 的 `row_range` 由
/// `ui.clip_rect()` 推出来(table.rs:650-666),滚出视口的行**不进语义树**。旧
/// TableBuilder 没有虚拟滚动,50 行全建构。迁入 egui_table 的动机之一就是虚拟滚动,
/// 所以「每一行都建构」不再是口径。新口径两条,都确定性、无噪声:
/// ① 视口装得下的行必须**全部**建构(面板拉高到装得下 50 行 → 50 颗全在 = 行不丢);
/// ② 视口装不下时,建构颗数**不随行数增长**(50 / 200 / 1000 行在同一副夹具里颗数相同)
///    —— 颗数一涨就是虚拟滚动没了、退化回全建构。
///
/// **不钉什么**:墙钟阈值。本机同一判据反复实测摆动很大(50 行 12.2 / 29.4 ms,1000 行
/// 214.7 / 512.1 ms —— 那批样本还是同批测试并发跑出来的):墙钟阈值在这里只会随机红。
/// 所以只留一条**数量级上限**(dev 3000 / release 300 ms)抓病态爆炸;真正的性能结论
/// 按手工实测记录在 DESIGN.md,不当 CI 钉。
#[test]
fn t7_table_row_count_and_virtual_scroll() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let built = |n: usize, size: [f32; 2]| -> usize {
        let shared = Arc::new(UiShared::new());
        feed_rows(&shared, demo_rows());
        shared.seed_trade_snap(trades_snap(
            (1..=n)
                .map(|i| trade_row(&format!("T{i}"), 100.0 + (i % 97) as f64, "螺纹"))
                .collect(),
        ));
        let mut harness = Harness::builder()
            .with_size(size)
            .build(|ctx| render_body(ctx, &shared));
        harness.run();
        harness.query_all_by_label("螺纹").count()
    };

    // ① 面板够高 → 30 行全建构(行不丢这条还在,只是换了前提:装得下)。
    //    1280×2400 的成交格实测装得下 38 行(本轮实量),30 行全在视口里。
    let tall = built(30, [1280.0, 2400.0]);
    assert_eq!(
        tall, 30,
        "30 行成交表在装得下它的面板里必须把每一行都建构出来(行不丢)"
    );

    // ② 同一副 1280×860 夹具:行数涨 20 倍,建构颗数不动。
    let (b50, b200, b1000) = (
        built(50, [1280.0, 860.0]),
        built(200, [1280.0, 860.0]),
        built(1000, [1280.0, 860.0]),
    );
    println!("T7 1280×860 建构颗数:50 行 → {b50},200 行 → {b200},1000 行 → {b1000}");
    assert!(b50 > 0, "成交表一颗粒都没有 = 表塌了");
    assert!(
        b50 < 50 && b1000 < 1000,
        "1280×860 的成交格装不下 50 行,装不下就不许全建构(虚拟滚动):{b50} / {b1000}"
    );
    assert_eq!(
        (b50, b200, b1000),
        (b50, b50, b50),
        "建构颗数必须只由视口决定,不随行数增长(一涨 = 虚拟滚动没了)"
    );

    // ③ 数量级闸:1000 行单帧建构成本。
    let shared = Arc::new(UiShared::new());
    feed_rows(&shared, demo_rows());
    shared.seed_trade_snap(trades_snap(
        (1..=1000)
            .map(|i| trade_row(&format!("T{i}"), 100.0 + (i % 97) as f64, "螺纹"))
            .collect(),
    ));
    let mut harness = harness_for(&shared);
    harness.run();
    let mut samples: Vec<f64> = Vec::new();
    for _ in 0..5 {
        let t0 = std::time::Instant::now();
        harness.run_steps(3);
        samples.push(t0.elapsed().as_secs_f64() * 1000.0 / 3.0);
    }
    samples.sort_by(|a, b| a.total_cmp(b));
    // 取 5 次里的最小值:被抢占的样本是机器噪声,最小值最接近真实建构成本。
    let c1000 = samples[0];
    let budget = if cfg!(debug_assertions) {
        3000.0
    } else {
        300.0
    };
    assert!(
        c1000 < budget,
        "1000 行单帧建构 {c1000:.1} ms ≥ {budget:.0} ms → 数量级退化(不是噪声能解释的量)"
    );
    println!("T7 最优单帧建构(ms):{c1000:.1}");
}

/// s72(BD-UI-43,由本轮临时诊断钉转正):合约表的**行线**必须落在相邻两行之间,
/// 不能压在自己那行的文字上(实拍毛病 8「行线切进行里」)。
///
/// 判据口径:行矩形从 AccessKit 语义树取(文字位置不靠颜色猜),行线从**本帧绘制指令**
/// 取(`Shape::LineSegment` 水平段,色 = `border`)。三条断言 = 可见根数 ≥ 10、间距均匀、
/// 每根都在两行之间且不压文字中心。原来行线靠像素扫描,已撤除(HANDOVER §17)。
/// **反向自检(测试方案 §3)**:旧算法 `y = body_top + row_h * (k + 0.5)`(行中心)
/// 在这套判据下必须红 —— 实测旧代码报「第 1 根行线 y=426 没落在第 1 行(max 432)
/// 与第 2 行(min 437)之间」。
#[test]
fn s72_contract_row_lines_land_between_rows() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = Arc::new(UiShared::new());
    const ROWS: usize = 13;
    let mut names: Vec<String> = Vec::with_capacity(ROWS);
    for i in 0..ROWS - 1 {
        let name = format!("螺纹钢26{i:02}合约名称");
        names.push(name.clone());
        shared.update_contract(&contract(
            ek_data::constant::Exchange::SHFE,
            &format!("rb26{i:02}"),
            &name,
        ));
    }
    names.push("精对苯二甲酸709".to_string());
    shared.update_contract(&contract(
        ek_data::constant::Exchange::CZCE,
        "TA709",
        "精对苯二甲酸709",
    ));
    shared.set_contracts_window_open(true);

    let mut harness = harness_for(&shared);
    let hit = ek_ui::fonts::apply_cjk_fonts(&harness.ctx);
    assert!(hit.is_some(), "验收环境必须有 CJK 候选字体");
    harness.run();

    let mut rows: Vec<egui::Rect> = Vec::with_capacity(ROWS);
    for n in &names {
        let node = harness
            .query_by_label(n)
            .unwrap_or_else(|| panic!("合约表必须有行「{n}」"));
        rows.push(node.rect());
    }
    rows.sort_by(|a, b| a.min.y.total_cmp(&b.min.y));

    // 行线 = 本帧绘制指令里的 `border` **水平线段**(render.rs 的 `p.hline(x, y, stroke)`)。
    // 表头带下边线是同一支色,但它画在第一行顶边之上 → 被 y 闸剔掉;
    // 横向滚动条的框是 rect 描边(不是 LineSegment),天然不进这条判据 ——
    // 原来靠像素扫「这根线下面跟着 #0E141B 还是 #19232D」才分得开。
    // 这道 x 闸必须有:主窗各表的带底横线也是 `border`,而它们的 y 恰好可能落进
    // 合约行之间的缝里(实测会把 13 行数成 13 根但间距 [32,32,32,25,7,32,…])。
    // 带 = 盖住合约表头行(「最小变动」)的那根 BG4 实心矩形(带底与描边 0.4.1 四期起
    // 是两支色,BG4 只指带底)。
    let anchor = harness
        .query_by_label("最小变动")
        .expect("合约表必须有「最小变动」表头")
        .rect();
    let shapes = shapes_of(&harness);
    let band = header_bands(&shapes, ek_ui::tokens::shadcn::BG4, 100.0)
        .into_iter()
        .find(|b| b.contains_rect(anchor))
        .expect("合约表必须有表头带(BG4 实心矩形盖住表头行)");
    // 0.8.2:行线 = `BORDER_SOFT`(参考站 td{border-bottom:var(--st-line-soft)})
    let mut lines: Vec<f32> = hlines(&shapes, ek_ui::tokens::shadcn::BORDER_SOFT)
        .into_iter()
        // 行线横跨整个表体宽(body 的 x_range)→ 必须落在这张表的带里,而且几乎一样宽
        // (未选中 tab 的 2px 下边线也是 `border`,但它只有 tab 那么宽,挡掉)。
        .filter(|(_, x)| {
            x.min >= band.min.x - 2.0 && x.max <= band.max.x + 2.0 && x.span() >= band.width() * 0.8
        })
        .map(|(y, _)| y)
        .filter(|y| *y > rows[0].min.y && *y <= rows[ROWS - 1].min.y)
        .collect();
    lines.sort_by(f32::total_cmp);
    lines.dedup();

    // 夹具 13 行,合约窗视口只装得下约 11 行 —— 滚出视口的行不画线(AccessKit
    // 仍报 13 个行节点)。所以判据是「至少 10 根、间距均匀、不压文字中心」,
    // 不是「恰好 12 根」(0.2.30 实测 10 根:468..756 间距 32 = 行高 26 + 缝 6)。
    assert!(
        lines.len() >= 10,
        "{ROWS} 行夹具里可见行线必须 ≥ 10 根,实测 {} 根:{:?}",
        lines.len(),
        lines
    );
    let gaps: Vec<f32> = lines.windows(2).map(|p| p[1] - p[0]).collect();
    for g in &gaps {
        assert!((g - gaps[0]).abs() <= 1.5, "行线间距必须均匀,实测 {gaps:?}");
    }
    for y in &lines {
        assert!(
            rows.windows(2)
                .any(|p| *y + 0.5 >= p[0].max.y && *y - 0.5 <= p[1].min.y),
            "行线 y={y:.1} 没落在任何相邻两行之间(行矩形 {rows:?})"
        );
        for (k, r) in rows.iter().enumerate() {
            let center = (r.min.y + r.max.y) * 0.5;
            assert!(
                (y - center).abs() >= 5.0,
                "行线 y={y:.1} 压在第 {} 行文字中心 {center:.1} 上(毛病 8 复发)",
                k + 1
            );
        }
    }
}

/// T8 五档盘口成列(毛病 6 的本体,BD-UI-45):下单侧「卖5…卖1 / 买1…买5」十行,档位标签 /
/// 「价」/「量」三格每行的**左边界**必须各落在同一 x(±1 px),且价与量必须走**等宽**数字。
/// 原来这支是 `ui.label("卖5  101.5  3")` —— 价与量靠**空格**对齐,位数一变整块错位。
/// **0.8.0 裁定 D(全左对齐)按白名单改向**:旧钉钉的是「价/量右边界同一 x」,那套机制
/// `ui_ext::num_cell` 已退役;旧病的治法是等宽数字,与贴不贴右无关(与 `t3` 同源口径)。
#[test]
fn t8_book_frame_price_and_volume_columns_are_aligned() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = Arc::new(UiShared::new());
    let mut form = shared.order_form();
    form.exchange = "SHFE".to_string();
    form.symbol = "rb2605".to_string();
    shared.set_order_form(form);
    // 五档价位数刻意差很多(1.0 / 12345.5 / 0.5),量同理(3 / 1234 / 2345):
    // 空格对齐在这种数据下必然错位,判据才有牙。
    shared.update_tick(&ek_data::tick::TickData {
        gateway_name: "ctp".to_string(),
        symbol: "rb2605".to_string(),
        exchange: ek_data::constant::Exchange::SHFE,
        name: "螺纹钢2605".to_string(),
        datetime: 36_000 * 1_000_000_000,
        last_price: 101.0,
        pct_change: 1.0,
        volume: 1234.0,
        open_price: 100.0,
        high_price: 103.0,
        low_price: 99.0,
        bid_price_1: 1.0,
        bid_volume_1: 7.0,
        bid_price_2: 12345.5,
        bid_volume_2: 1234.0,
        bid_price_3: 98.5,
        bid_volume_3: 3.0,
        bid_price_4: 0.5,
        bid_volume_4: 8.0,
        bid_price_5: 9.2,
        bid_volume_5: 45.0,
        ask_price_1: 101.5,
        ask_volume_1: 6.0,
        ask_price_2: 12346.5,
        ask_volume_2: 2345.0,
        ask_price_3: 102.5,
        ask_volume_3: 2.0,
        ask_price_4: 103.5,
        ask_volume_4: 12.0,
        ask_price_5: 104.5,
        ask_volume_5: 123.0,
        update_time: "10:00:00".to_string(),
        ..ek_data::tick::TickData::default()
    });
    let mut harness = harness_for(&shared);
    let hit = ek_ui::fonts::apply_cjk_fonts(&harness.ctx);
    assert!(hit.is_some(), "验收环境必须有 CJK 候选字体");
    harness.run();
    // 判据口径(BD-UI-55 收紧):盘口一行 = 档 / 价 / 量 三格,按**行锚**取格。
    // 原来只按 x<280 切「下单侧」,而行情格与盘口格同名是常态(夹具里 tick.volume
    // = 1234 与 bid_volume_2 = 1234 同串,行情格的「成交量」列也在左上角)→ x 切
    // 挡不住同名(0.4.1 实锤:量格数成 11 颗)。换成「与档位标签同高、且在它右边」:
    // 顺带把「档 / 价 / 量 三格同一行」也钉住(旧口径没这条),并且不假设盘口在哪个 y
    // (整窗 dock 化后「行情带在上、盘口在下」这条前提早就没了)。
    let spread = |vals: &[f32]| {
        let lo = vals.iter().copied().fold(f32::INFINITY, f32::min);
        let hi = vals.iter().copied().fold(f32::NEG_INFINITY, f32::max);
        hi - lo
    };
    const BOOK_ROWS: [(&str, &str, &str); 10] = [
        ("卖5", "104.5", "123"),
        ("卖4", "103.5", "12"),
        ("卖3", "102.5", "2"),
        ("卖2", "12346.5", "2345"),
        ("卖1", "101.5", "6"),
        ("买1", "1", "7"),
        ("买2", "12345.5", "1234"),
        ("买3", "98.5", "3"),
        ("买4", "0.5", "8"),
        ("买5", "9.2", "45"),
    ];
    let mut tag_lefts: Vec<f32> = Vec::new();
    let mut price_lefts: Vec<f32> = Vec::new();
    let mut vol_lefts: Vec<f32> = Vec::new();
    let mut mono: Vec<(String, Option<bool>)> = Vec::new();
    for (tag, price, vol) in BOOK_ROWS {
        let anchor = harness
            .query_all_by_label(tag)
            .map(|n| n.rect())
            .find(|r| r.min.x < 280.0)
            .unwrap_or_else(|| panic!("盘口必须有档位标签「{tag}」这一格"));
        tag_lefts.push(anchor.min.x);
        let p = harness
            .query_all_by_label(price)
            .map(|n| n.rect())
            .find(|r| {
                (r.center().y - anchor.center().y).abs() < 3.0 && r.min.x > anchor.max.x - 2.0
            })
            .unwrap_or_else(|| {
                panic!("盘口「{tag}」这一行必须有价格格「{price}」(与档位同高、在档位右边)")
            });
        price_lefts.push(p.min.x);
        mono.push((price.to_string(), monospace_at(&harness, price, &p)));
        let v = harness
            .query_all_by_label(vol)
            .map(|n| n.rect())
            .find(|r| (r.center().y - anchor.center().y).abs() < 3.0 && r.min.x > p.max.x - 2.0)
            .unwrap_or_else(|| {
                panic!("盘口「{tag}」这一行必须有量格「{vol}」(与档位同高、在价格格右边)")
            });
        vol_lefts.push(v.min.x);
        mono.push((vol.to_string(), monospace_at(&harness, vol, &v)));
    }
    assert!(
        spread(&price_lefts) <= 1.0,
        "盘口「价」列必须左沿成列(毛病 6 由三列小表 + 等宽守),实测 {price_lefts:?}"
    );
    assert!(
        spread(&vol_lefts) <= 1.0,
        "盘口「量」列必须左沿成列(毛病 6 由三列小表 + 等宽守),实测 {vol_lefts:?}"
    );
    assert!(
        spread(&tag_lefts) <= 1.0,
        "盘口档位标签必须同一列,实测 {tag_lefts:?}"
    );
    // 盘口帧在夹具里可能被面板高度裁掉几行(被裁的行连文字形状都没有)→ 只核在场的那些,
    // 并钉「在场数下限」= 12(十行 × 价/量两格共 20 个,裁到 12 以下这条判据就没牙了)。
    let present: Vec<(String, bool)> = mono
        .into_iter()
        .filter_map(|(s, m)| m.map(|ok| (s, ok)))
        .collect();
    assert!(
        present.len() >= 12,
        "盘口数字格形状在场数不足(判据没牙),实测 {n} 个(价 + 量共 20 格)",
        n = present.len()
    );
    for (s, ok) in present {
        assert!(
            ok,
            "盘口数字格「{s}」必须走等宽字体(撤右对齐后「成列」靠它)"
        );
    }
}

// ================= 0.2.30 Wave B 判据(B 测试方案 U3b / U6 / U7)=================

/// U3b 涨跌色**落在这一帧上**的钉:同一张行情表里,涨行的涨跌幅必须红、跌行必须绿。
/// 判据形状 = 本帧文字形状的实际取色(不是「画面里有红点」那种松判据:买列本来就是红,
/// 松判据挡不住「涨跌幅全染红」)+ 唯一入口 `tokens::rise_fall` 的函数钉 + 源码机械扫描。
/// 原来这条是 AccessKit 矩形内数两种颜色的像素,已撤除(HANDOVER §17)。
#[test]
fn u3b_market_band_change_column_colors_by_direction() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = Arc::new(UiShared::new());
    feed_rows(&shared, demo_rows());
    shared.update_tick(&tick(
        ek_data::constant::Exchange::SHFE,
        "rb2605",
        "螺纹钢2605",
        101.0,
        2.5,
    ));
    shared.update_tick(&tick(
        ek_data::constant::Exchange::SHFE,
        "cu2709",
        "铜2709",
        12345.0,
        -3.5,
    ));
    let mut harness = harness_for(&shared);
    let hit = ek_ui::fonts::apply_cjk_fonts(&harness.ctx);
    assert!(hit.is_some(), "验收环境必须有 CJK 候选字体");
    harness.run();
    // 语义树:两格都在。
    assert!(
        harness.query_all_by_label("+2.50").next().is_some(),
        "必须有涨跌幅格「+2.50」"
    );
    assert!(
        harness.query_all_by_label("-3.50").next().is_some(),
        "必须有涨跌幅格「-3.50」"
    );
    // 这一帧的文字形状:实际颜色。
    let shapes = shapes_of(&harness);
    let up = texts_containing(&shapes, "+2.50");
    let down = texts_containing(&shapes, "-3.50");
    assert!(
        !up.is_empty() && !down.is_empty(),
        "本帧必须画出「+2.50」与「-3.50」两串文字"
    );
    let colors = |v: &[(String, egui::Rect, egui::Color32)]| -> Vec<egui::Color32> {
        v.iter().map(|(_, _, c)| *c).collect()
    };
    assert!(
        up.iter()
            .all(|(_, _, c)| *c == ek_ui::tokens::semantic::RISE),
        "涨行「+2.50」必须是 RISE(红 #E05050),实测 {:?}",
        colors(&up)
    );
    assert!(
        down.iter()
            .all(|(_, _, c)| *c == ek_ui::tokens::semantic::FALL),
        "跌行「-3.50」必须是 FALL(绿 #2E9E2E),实测 {:?}",
        colors(&down)
    );
    // 唯一入口钉(毛病 3 的语义半边):涨跌色只能从 `rise_fall` 出,不许各处现编。
    // 0.8.0:入口要 ctx(取当前档的色);夹具这一帧是缺省深档 → 钉的仍是深档那两支。
    assert_eq!(
        ek_ui::tokens::rise_fall(&harness.ctx, 2.5),
        ek_ui::tokens::semantic::RISE
    );
    assert_eq!(
        ek_ui::tokens::rise_fall(&harness.ctx, -3.5),
        ek_ui::tokens::semantic::FALL
    );
    assert_eq!(
        ek_ui::tokens::rise_fall(&harness.ctx, 0.0),
        ek_ui::tokens::shadcn::TEXT1
    );
    assert_ne!(
        ek_ui::tokens::semantic::RISE,
        ek_ui::tokens::semantic::FALL,
        "红涨绿跌不许同色"
    );
    let render_src = std::fs::read_to_string(concat!(env!("CARGO_MANIFEST_DIR"), "/src/render.rs"))
        .expect("render.rs 必须可读");
    assert!(
        render_src.contains("crate::tokens::rise_fall("),
        "涨跌幅那一列必须走 `tokens::rise_fall`(不许自己 `if v > 0 {{红}} else {{绿}}`)"
    );
}

// ============ 0.4.0 整窗 dock 化(BD-UI-53)的判据钉 ============
//
// 0.3.0 的 Wave C 只把「下带右侧数据区」搬进 dock,行情带 / 下单侧仍是原生面板
// (BD-UI-48)。0.4.0 按用户裁定推翻它:**菜单条之外全是 dock 格子** ——
// 行情按所一格(6 格)、下单侧一格、数据面「每个一个」(委托 / 未成交 / 成交 / 持仓 /
// 资金 / 日志),组内那三条二级 tab 条撤除(dock 的 tab 条就是那一层)。
// 三条 spike 口径沿用:①dock tab 标签不进 AccessKit(本次实测同样成立)→ 判据一律从树取;
// ②默认树必须显式 `split`;③核心区不能被关。

/// V1 框架形状钉(0.4.1 BD-UI-54,再次反转 0.4.0 的整窗 dock):菜单条/行情带/
/// 下单侧是原生面板,数据区 = 薄 QSplitter;egui_dock 依赖与 dock.rs 撤除。
#[test]
fn v1_native_panels_are_the_frame() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let src = std::fs::read_to_string(concat!(env!("CARGO_MANIFEST_DIR"), "/src/render.rs"))
        .expect("render.rs 必须可读");
    for need in [
        "TopBottomPanel::top(\"menu_bar\")",
        "TopBottomPanel::top(\"market_band\")",
        "SidePanel::left(\"order_side\")",
        "render_data_area",
    ] {
        assert!(src.contains(need), "V1:原生容器必须有 {need:?}");
    }
    // dock 不得回归(反向钉,挡「又搬回去」)。
    assert!(
        !src.contains("egui_dock"),
        "V1:render.rs 不得再碰 egui_dock"
    );
    assert!(
        !src.contains("crate::dock::"),
        "V1:render.rs 不得再引用 dock 模块"
    );
    assert!(
        !std::path::Path::new(&concat!(env!("CARGO_MANIFEST_DIR"), "/src/dock.rs")).exists(),
        "V1:src/dock.rs 必须删除"
    );
    assert!(
        src.contains("crate::splitters::quad"),
        "V1:数据区两刀必须走薄 QSplitter(0.4.1 九期 BD-UI-62 起 = 2×2 贯穿两刀 `quad`)"
    );
}

/// V2 分刀钉(0.4.1 BD-UI-54 回归原生容器):数据区两刀缺省 50:50
/// (= Python `right_splitter`),行情带/下单侧面板缺省尺寸 = Python 像素
/// (`setSizes([240,560])` 上带 / `setFixedWidth(300)`),六所 tab 序钉死。
#[test]
fn v2_data_split_defaults_to_python_fractions() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = ek_ui::state::UiShared::new();
    let s = shared.data_split();
    assert_eq!(s.col, 0.5, "V2:左右刀缺省 50:50");
    assert_eq!(s.row, 0.5, "V2:上下刀缺省 50:50");
    assert_eq!(
        ek_ui::tokens::MARKET_BAND_HEIGHT,
        240.0,
        "V2:行情带缺省高 = Python setSizes([240,560]) 上带"
    );
    assert_eq!(
        ek_ui::tokens::ORDER_SIDE_WIDTH,
        300.0,
        "V2:下单侧缺省宽 = Python setFixedWidth(300)"
    );
    assert_eq!(
        ek_ui::state::MARKET_ORDER.len(),
        6,
        "V2:行情带六所固定 tab(用户裁定「每个交易所都要一个」)"
    );
    // 拖拽回调路径的夹取:越界份额就地停住(QSplitter minimumSize 语义)。
    shared.set_data_split(ek_ui::state::DataSplit {
        col: 0.9,
        row: 0.05,
    });
    let s = shared.data_split();
    assert!(
        (s.col - 0.85).abs() <= 1e-6 && (s.row - 0.15).abs() <= 1e-6,
        "V2:份额必须夹取到 [0.15, 0.85],实测 {s:?}"
    );
    shared.reset_layout();
    let s = shared.data_split();
    assert_eq!(
        (s.col, s.row),
        (0.5, 0.5),
        "V2:恢复布局 = 回 Python right_splitter 口径"
    );
}

/// V3 身份钉:四组 tab 标题可见 + 「恢复布局」入口在菜单里。
#[test]
fn v3_dock_tabs_are_visible_and_layout_can_be_reset() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = UiShared::new();
    let harness = harness_for(&shared);
    for title in ["委托", "成交", "持仓", "资金"] {
        assert!(
            harness.query_all_by_label_contains(title).count() >= 1,
            "V3:dock tab「{title}」必须可见"
        );
    }
    assert!(
        harness.query_all_by_label("恢复布局").count() == 1,
        "V3:菜单里必须有且只有一个「恢复布局」钮"
    );
}

/// V4 不可关钉(0.4.1):数据区没有关闭钮可点(原生方向 = 根本没有关的概念)。
#[test]
fn v4_monitor_groups_cannot_be_closed() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = UiShared::new();
    let harness = harness_for(&shared);
    let close_btns = harness.query_all_by_label_contains("×").count();
    assert_eq!(
        close_btns, 0,
        "V4:数据区不能被关,实测查到 {close_btns} 个关闭钮"
    );
}

/// V5 样式派生钉:容器层样式只从 tokens 派生,`splitters.rs` 里不许出现字面量颜色。
///
/// 0.8.0 双档(BD-UI-61)**按白名单改向**:旧钉要求文件里出现 `shadcn::BORDER`/`shadcn::ACCENT4`
/// 两支**深档常量**串 —— 双档之后那套写法正是「浅档界面里唯一一块深档」的来源(s89 在浅档帧里
/// 抓到两条深档分隔条,实锤)。现在钉的是:必须走 `tokens::palette(ui.ctx())`(跟当前档),
/// 且**不许**再直写深档常量串;字面量颜色的禁令不变。
#[test]
fn v5_container_style_derives_from_tokens_only() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let split = std::fs::read_to_string(concat!(env!("CARGO_MANIFEST_DIR"), "/src/splitters.rs"))
        .expect("splitters.rs 必须可读");
    for needle in ["from_rgb", "Color32::"] {
        assert!(
            !split.contains(needle),
            "V5:splitters.rs 里出现了字面量颜色 {needle:?} —— 分隔条必须只吃色板令牌"
        );
    }
    // 必须走当前档色板(判据 s89 钉落屏,这条钉形状)。
    assert!(
        split.contains("crate::tokens::palette(ui.ctx())"),
        "V5:分隔条必须从**当前档**色板取色(tokens::palette(ui.ctx())),实测 splitters.rs 里没有这一支"
    );
    for banned in ["shadcn::BG1", "shadcn::BORDER", "shadcn::ACCENT4"] {
        assert!(
            !split.contains(banned),
            "V5:splitters.rs 不许再直写深档常量 {banned:?}(浅档下它就是那块唯一的深档)"
        );
    }
    for needle in ["pal.border", "pal.accent4"] {
        assert!(
            split.contains(needle),
            "V5:分隔条必须吃色板里的描边/高亮两支(与 chrome 同源),实测缺「{needle}」"
        );
    }
}

// ============ 0.3.1 Wave D:交互复刻(BD-UI-49)的判据钉 ============
//
// 判据先写、在 0.3.0 上跑一遍必须全红(这些交互今天一个都没有),红证据写进改动声明。
// 纪律:不碰墙钟(夹具用固定 epoch 纳秒)、不假设屏幕尺寸、判据一律 `contains`。

/// Wave D 夹具:三笔成交,价格故意乱序(101 / 3.5 / 12.345),时间固定 epoch。
fn wave_d_shared() -> UiShared {
    let shared = UiShared::new();
    let trade = |id: &str, symbol: &str, price: f64, ns: i64| ek_data::trade::TradeData {
        gateway_name: "ctp".to_string(),
        symbol: symbol.to_string(),
        exchange: ek_data::constant::Exchange::SHFE,
        orderid: format!("CTP_{id}"),
        tradeid: id.to_string(),
        direction: Some(ek_data::constant::Direction::LONG),
        offset: ek_data::constant::Offset::OPEN,
        price,
        volume: 1.0,
        datetime: Some(ns),
        name: "螺纹钢2605".to_string(),
        ..ek_data::trade::TradeData::default()
    };
    shared.seed_trade_snap(ek_ui::state::TradeSnap {
        trades: vec![
            trade("T-1", "rb2605", 101.0, 36_000_000_000_000),
            trade("T-2", "cu2709", 3.5, 36_001_000_000_000),
            trade("T-3", "au2712", 12.345, 36_002_000_000_000),
        ],
        ..ek_ui::state::TradeSnap::default()
    });
    shared
}

/// 往**同一拍**输入队列塞点击:`Harness::input_mut` 在 kittest 0.33.3 里不带闭包,
/// 直接返回 `&mut egui::RawInput`(实测 lib.rs:463)。`times = 2` 就是双击 —— egui 只在
/// 同一拍里看到两次点击(间隔 0 < `click_timeout`)才认双击。事件类型在 0.33 叫 `egui::Event`
/// (不叫 `InputEvent`,实测编译错)。
fn click_at(
    harness: &mut egui_kittest::Harness<'_>,
    pos: egui::Pos2,
    button: egui::PointerButton,
    times: usize,
) {
    let input = harness.input_mut();
    // 先把指针挪过去再按:egui 的二级点击走「上一拍指针就在这颗格上」那条路
    // (探针用 Node::click_secondary() 能成,就是因为 kittest 自己先移动了指针)。
    input.events.push(egui::Event::PointerMoved(pos));
    for _ in 0..times {
        for pressed in [true, false] {
            input.events.push(egui::Event::PointerButton {
                pos,
                button,
                pressed,
                modifiers: egui::Modifiers::NONE,
            });
        }
    }
}

/// 成交表「价格」表头的点击位置(W1 用两次:第一次点排序、第二次点翻向)。
///
/// 两件事一起做,是因为它们必须同时成立:① 委托表与成交表的表头**同高**,只按 y 筛会挑到
/// 委托表的「价格」(本轮实锤:点击落在 x=746,而成交表的「价格」在 x=1045 一带);
/// ② 列序照 Python 之后「成交号」落在横向裁剪之外,不能再用它当锚点 —— 改用名称列
/// (第 2 列,恒可见)与「成交金额」(第 8 列)夹出窗口。
fn trades_price_header_pos(harness: &mut egui_kittest::Harness<'_>) -> egui::Pos2 {
    let head = harness
        .query_all_by_label_contains("成交金额")
        .next()
        .expect("W1:成交表「成交金额」表头必须查得到")
        .rect();
    let name = harness
        .query_all_by_label_contains("螺纹钢2605")
        .next()
        .expect("W1:成交表名称格必须查得到")
        .rect();
    harness
        .query_all_by_label_contains("价格")
        .find(|n| {
            (n.rect().min.y - head.min.y).abs() < 2.0
                && n.rect().min.x > name.min.x - 2.0
                && n.rect().min.x < head.max.x + 2.0
        })
        .expect("W1:成交表那一行的「价格」表头必须查得到")
        .rect()
        .center()
}

/// W1 排序入口:点成交表「价格」表头 → 行序按价格重排(升序),再点一次 → 降序。
#[test]
fn w1_clicking_the_price_header_sorts_the_trades_table() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = wave_d_shared();
    // 宽夹具(BD-UI-55):判据按成交表「成交号」列(第 10 列)的 y 读行序,1280 宽时
    // 那一列在横向裁剪外,egui_table 不建构裁剪外的格(见 `harness_wide_for`)。
    let mut harness = harness_wide_for(&shared);
    harness.run();
    let y_of = |h: &mut egui_kittest::Harness<'_>, id: &str| {
        h.query_all_by_label_contains(id)
            .next()
            .unwrap_or_else(|| panic!("W1:夹具成交「{id}」必须查得到"))
            .rect()
            .min
            .y
    };
    // 夹具插入序 = T-1(101) 在上;按价格升序应该是 T-2(3.5) 在上。
    let before = (y_of(&mut harness, "T-1"), y_of(&mut harness, "T-2"));
    println!("W1 点表头前:T-1 y={:.1} T-2 y={:.1}", before.0, before.1);
    assert!(before.0 < before.1, "W1 前置条件:未排序时夹具按插入序");

    // 成交表与委托表的表头带在同一行(同一个 y)—— 只按 y 筛会挑到**委托表**的「价格」
    // (本轮实锤:点击落在 x=746,而成交表的「价格」格在 x=1045..1074)。
    // 必须同时按 x 筛:成交表在「螺纹钢2605」(名称列,第 2 列)右边、在「成交金额」(第 8 列)左边。
    // 0.3.3 Wave F:列序照 Python 后「成交号」在第 10 列(裁剪外),不再能当锚点。
    let pos = trades_price_header_pos(&mut harness);
    // 表头文字是静态文本节点,`Node::click()` 走的是 AccessKit 动作,静态文本没有动作
    // (本轮实锤:点完 `table_sort` 还是 None)—— 只能往输入队列塞真实点击。
    println!("W1 诊断:点击位置 = {pos:?}");
    click_at(&mut harness, pos, egui::PointerButton::Primary, 1);
    harness.run();
    println!(
        "W1 诊断:点表头后 shared.table_sort(\"trade_grid\") = {:?}",
        shared.table_sort("trade_grid")
    );
    let asc = (y_of(&mut harness, "T-1"), y_of(&mut harness, "T-2"));
    println!("W1 第一次点后:T-1 y={:.1} T-2 y={:.1}", asc.0, asc.1);
    assert!(
        asc.1 < asc.0,
        "W1:点「价格」表头后必须按价格升序(T-2=3.5 应到 T-1=101 之上),实测 T-1 y={:.1} T-2 y={:.1}",
        asc.0,
        asc.1
    );

    let pos2 = trades_price_header_pos(&mut harness);
    click_at(&mut harness, pos2, egui::PointerButton::Primary, 1);
    harness.run();
    let desc = (y_of(&mut harness, "T-1"), y_of(&mut harness, "T-2"));
    println!("W1 第二次点后:T-1 y={:.1} T-2 y={:.1}", desc.0, desc.1);
    assert!(
        desc.0 < desc.1,
        "W1:再点一次必须翻成降序,实测 T-1 y={:.1} T-2 y={:.1}",
        desc.0,
        desc.1
    );
}

/// W2 更新中不排序(Python `widget.py:396-419` 那个病的正解):排序只作用在**喂表前的快照副本**上,
/// 数据面本身不被界面排序改写。机械扫源码钉住。
#[test]
fn w2_sorting_applies_to_a_snapshot_copy_not_the_model() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let render = std::fs::read_to_string(concat!(env!("CARGO_MANIFEST_DIR"), "/src/render.rs"))
        .expect("render.rs 必须可读");
    assert!(
        render.contains("sorted_rows"),
        "W2:渲染侧必须有一支「取快照副本再排序」的入口(sorted_rows),不许就地排模型"
    );
    let state = std::fs::read_to_string(concat!(env!("CARGO_MANIFEST_DIR"), "/src/state.rs"))
        .expect("state.rs 必须可读");
    assert!(
        state.contains("table_sorts"),
        "W2:排序键必须住在界面状态(table_sorts),不混进数据模型"
    );
}

/// W3 双击联动:双击成交行 → 下单面板「代码」变成该合约。
#[test]
fn w3_double_clicking_a_trade_row_fills_the_order_form() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = wave_d_shared();
    let mut harness = harness_for(&shared);
    harness.run();
    // kittest 0.3.0 的 Node 没有 `double_click`（实测方法清单只有 click / click_secondary /
    // click_button），而且 Node 借住 harness、不能跨 `harness.run()` 活着。正解：自己往
    // 同一拍输入队列塞两次点击 —— egui 在同一拍里看到两次点击（间隔 0 < `click_timeout`）
    // 才认双击；中间 run 一拍会把间隔推到超时之外（本轮实撞）。
    // 0.3.3 Wave F:双击点的是「代码」列(cu2709)而不是「成交号」列 —— 列序照 Python 后
    // 成交号在第 10 列、落在横向裁剪之外,裁剪外的点击打不到那一格(格还在树里,但命中测试不吃)。
    let pos = harness
        .query_all_by_label_contains("cu2709")
        .next()
        .expect("W3:夹具成交「cu2709」必须查得到")
        .rect()
        .center();
    click_at(&mut harness, pos, egui::PointerButton::Primary, 2);
    harness.run();
    let form = shared.order_form();
    println!("W3 双击 T-2(cu2709)后下单代码 = {:?}", form.symbol);
    assert_eq!(
        form.symbol, "cu2709",
        "W3:双击成交行必须把该合约填进下单面板"
    );
}

/// W5 右键菜单:成交表行右键 → 菜单出得来(Python 有,我们之前没有),且菜单项是**活的**。
/// 0.4.1 五期(BD-UI-58)起菜单只剩「保存数据」:「调整列宽」退役(列可拖 + 列线 = 全表固定形制)。
///
/// 0.3.3 收欠账:菜单改挂在首格的**真控件**上(`Label` + `Sense::click()` + `context_menu`),
/// 不再靠「收格矩形 + 表外层补 interact」—— 体表格的格吃过 hit-test、后补的 interact 又与表
/// 不同层,那条路在 kittest 里永远拿不到二级点击。这一钉从 `#[ignore]` 收回成活钉。
#[test]
fn w5_right_click_on_a_table_row_opens_the_menu() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = wave_d_shared();
    let mut harness = harness_for(&shared);
    harness.run();
    // 右键点在「代码」列(第 1 列,恒在可视区内):列序照 Python 后
    // 「成交号」在第 10 列、落在横向裁剪之外,裁剪外的点击打不到。
    let pos = harness
        .query_all_by_label_contains("rb2605")
        .next()
        .expect("W5:夹具成交「rb2605」必须查得到")
        .rect()
        .center();
    click_at(&mut harness, pos, egui::PointerButton::Secondary, 1);
    harness.run();
    let n_save = harness.query_all_by_label("保存数据").count();
    println!("W5 右键后「保存数据」节点数 = {n_save}");
    assert!(n_save >= 1, "W5:右键菜单里必须有「保存数据」");
    // 0.4.1 五期(BD-UI-58):「调整列宽」从菜单里退役 —— 列边界可拖 + 列线是全部表的
    // 固定形制(见 render.rs `pinned_table_impl_cols` 的 `resizable` 恒开),留着这颗钮
    // 就是用户 0.3.3 立这条钉时点名要挡的「空壳钮」。这一半判据反过来数:必须 0 个。
    let gone = harness.query_all_by_label("调整列宽").count();
    println!("W5 右键后「调整列宽」节点数 = {gone}(应为 0)");
    assert_eq!(gone, 0, "W5:「调整列宽」已退役,菜单里不许还挂着这颗空壳钮");

    // 「保存数据」也要是活的:菜单还开着就直接点它 → `target/ek-ui-trade_grid.csv` 落地,
    // 而且**表头与每行字段数与屏幕同源**(12 列)—— 这条挡「CSV 与表各自一套列」。
    // (旧流程在这里补第二次右键,是因为前一颗钮「调整列宽」把菜单关了;那颗钮退役后菜单
    // 还开着,再右键反而把它关掉 —— 0.4.1 五期实撞:第二次 Secondary 点击 = 关菜单。)
    let csv = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("target/ek-ui-trade_grid.csv");
    let _ = std::fs::remove_file(&csv);
    harness.get_by_label("保存数据").click_accesskit();
    harness.run();
    let text = std::fs::read_to_string(&csv)
        .unwrap_or_else(|e| panic!("W5:点「保存数据」必须落地 {}: {e}", csv.display()));
    let lines: Vec<&str> = text.lines().collect();
    println!("W5 CSV 行数 = {},表头 = {:?}", lines.len(), lines.first());
    assert_eq!(
        lines.first().copied(),
        Some("代码,名称,交易所,方向,开平,价格,数量,成交金额,时间,成交号,委托号,接口"),
        "W5:CSV 表头必须与屏幕表头逐字同源"
    );
    assert_eq!(lines.len(), 1 + 3, "W5:三笔成交 → 表头 + 3 行");
    for (i, l) in lines.iter().skip(1).enumerate() {
        assert_eq!(
            l.split(',').count(),
            12,
            "W5:CSV 第 {} 行必须 12 个字段(与表头列数同源),实测 {l:?}",
            i + 1
        );
    }
}

/// W6 数字与时间格式定死:价格 = `round 3`(整数不带小数点),时间 = `HH:MM:SS.mmm`(+08 墙钟)。
/// 夹具时间是固定 epoch 纳秒,判据不读当前时间。
#[test]
fn w6_number_and_time_formats_are_fixed() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    // 纯函数面:固定输入 → 固定输出。
    assert_eq!(ek_ui::format::price(101.0), "101");
    assert_eq!(ek_ui::format::price(3.5), "3.5");
    assert_eq!(ek_ui::format::price(12.345), "12.345");
    assert_eq!(ek_ui::format::price(12.3456), "12.346");
    // 36_000_000_000_000 ns = 1970-01-01 10:00:00 UTC = 北京 18:00:00.000
    assert_eq!(
        ek_ui::format::time_hms_millis(Some(36_000_000_000_000)),
        "18:00:00.000"
    );
    assert_eq!(ek_ui::format::time_hms_millis(None), "-");
    assert_eq!(
        ek_ui::format::date_ymd(Some(36_000_000_000_000)),
        "1970-01-01"
    );

    // 渲染面:成交表「时间」列必须出现 `HH:MM:SS.mmm` 形状。
    // 0.8.0 全左对齐:表头文字起笔吃格内边距(判据 s91)→ 每列的表头侧最小宽 +6,
    // 12 列的成交表在 1280 宽夹具里把第 9 列(「时间」)推出了裁剪 → 这一条改用**宽夹具**
    // (与 W1 同源口径,列在裁剪外 egui_table 不建构格,不是缺陷)。
    let shared = wave_d_shared();
    let mut harness = harness_wide_for(&shared);
    harness.run();
    // 夹具三笔的 epoch 纳秒固定 → 北京墙钟 18:00:00.000 / :01.000 / :02.000
    // (判据不读当前时间;kittest 没有 `query_all_by_predicate`,改查定死字符串)。
    let count_of = |h: &mut egui_kittest::Harness<'_>, needle: &str| -> usize {
        h.query_all_by_label_contains(needle).count()
    };
    if count_of(&mut harness, "18:00:00.000") == 0 {
        // 宽夹具里仍被裁到外面(列总宽 > 格宽)→ 照 T4 的形状横向滚一下再读(滚动是
        // 让被裁列**可达**的正规路径,不是放宽判据)。
        let hover_x = harness
            .query_all_by_label("成交金额")
            .next()
            .expect("W6:成交表必须有「成交金额」表头(悬停锚点)")
            .rect()
            .center()
            .x;
        harness.hover_at(egui::pos2(hover_x, 320.0));
        harness.step();
        for _ in 0..4 {
            harness.event(egui::Event::MouseWheel {
                unit: egui::MouseWheelUnit::Point,
                delta: egui::vec2(-260.0, 0.0),
                modifiers: egui::Modifiers::NONE,
            });
            harness.step();
        }
    }
    for t in ["18:00:00.000", "18:00:01.000", "18:00:02.000"] {
        let n = count_of(&mut harness, t);
        println!("W6 渲染里「{t}」标签数 = {n}");
        assert!(n >= 1, "W6:成交表时间列必须出现 {t}(HH:MM:SS.mmm 口径)");
    }
}

/// W7 退出确认:关主窗先弹确认,确认前不退。
/// 钉的是机制形状(源码扫描):拦关闭用 egui 0.33 的 `ViewportCommand::CancelClose`,
/// 放行要用户在确认窗里点「确认退出」才重发 `Close`。
/// 为什么不是界面判据:kittest 没有「点窗口关闭按钮」这个动作,`close_requested` 只能由真实
/// 窗口事件置起来 —— 这条只能钉机制;最后一眼走实跑行为核(启动 → 请求关窗 →
/// 确认窗在场且进程不退),不出图。
#[test]
fn w7_closing_the_window_asks_for_confirmation_first() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let read = |f: &str| {
        std::fs::read_to_string(format!("{}/{}", env!("CARGO_MANIFEST_DIR"), f))
            .unwrap_or_else(|_| panic!("{f} 必须可读"))
    };
    let render = read("src/render.rs");
    let state = read("src/state.rs");
    assert!(
        render.contains("close_requested()") && render.contains("ViewportCommand::CancelClose"),
        "W7:render.rs 必须拦下关闭请求(CancelClose),不许让窗口一声不响就退"
    );
    assert!(
        render.contains("ViewportCommand::Close") && render.contains("确认退出"),
        "W7:必须有一条放行路(确认窗里的「确认退出」重发 Close)"
    );
    assert!(
        state.contains("exit_confirm_open") && state.contains("exit_confirmed"),
        "W7:确认状态要住在 UiShared(确认窗开合 + 已确认放行位),不能是 render 里的局部变量"
    );
}

// ===================== Wave D 欠账收口(0.3.3,BD-UI-49 尾巴)=====================
//
// 0.3.1 只把「点表头排序」接在成交表上;委托表 / 持仓表 / 行情带三张表连入口都没有
// (表头 interact 一直是通的,只是没人接 `clicked`)。这三条钉的判据形状与 W1 同:
// 拿 AccessKit 行矩形读**行序**,不读像素;表头是静态文本节点,只能往输入队列塞真点击。

/// 委托行夹具(W8):三笔委托,价格故意乱序(101 / 3.5 / 12.345),委托号 O-1..O-3。
fn w8_order(gw: &str, id: &str, symbol: &str, price: f64) -> ek_data::order::OrderData {
    ek_data::order::OrderData {
        gateway_name: gw.to_string(),
        symbol: symbol.to_string(),
        exchange: ek_data::constant::Exchange::SHFE,
        orderid: id.to_string(),
        direction: Some(ek_data::constant::Direction::LONG),
        offset: ek_data::constant::Offset::OPEN,
        price,
        volume: 1.0,
        status: ek_data::constant::Status::ALLTRADED,
        datetime: Some(36_000_000_000_000),
        ..ek_data::order::OrderData::default()
    }
}

/// W8 委托表排序:点「价格」表头 → 行序按价格升序(再点一次降序)。
/// 红证据(0.3.2 上跑):点完 `shared.table_sort("order_grid")` 仍是 None,行序不动。
#[test]
fn w8_clicking_the_price_header_sorts_the_orders_table() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = Arc::new(UiShared::new());
    feed_rows(&shared, demo_rows());
    shared.seed_trade_snap(ek_ui::state::TradeSnap {
        orders: vec![
            w8_order("ctp", "O-1", "rb2605", 101.0),
            w8_order("ctp", "O-2", "cu2709", 3.5),
            w8_order("ctp", "O-3", "au2712", 12.345),
        ],
        ..ek_ui::state::TradeSnap::default()
    });
    // 宽夹具(BD-UI-55):判据按委托表「委托号」列(第 14 列)的 y 读行序,1280 宽时
    // 那一列在横向裁剪外,egui_table 不建构裁剪外的格(见 `harness_wide_for`)。
    let mut harness = harness_wide_for(&shared);
    let hit = ek_ui::fonts::apply_cjk_fonts(&harness.ctx);
    assert!(hit.is_some(), "验收环境必须有 CJK 候选字体");
    harness.run();
    let y_of = |h: &mut egui_kittest::Harness<'_>, id: &str| {
        h.query_all_by_label_contains(id)
            .next()
            .unwrap_or_else(|| panic!("W8:夹具委托「{id}」必须查得到"))
            .rect()
            .min
            .y
    };
    let before = (y_of(&mut harness, "O-1"), y_of(&mut harness, "O-2"));
    assert!(before.0 < before.1, "W8 前置条件:未排序时按插入序");

    // 锚点:「总量」是委托表**专属**表头(全仓只此一处)→ 用它定表头行 y;
    // 委托表与成交表的表头**同高**,按 y 筛之后取 x 最小的那颗 = 左叶的委托表
    // (下单面板里也有一个「价格」label,x≈8,靠 y 排掉)。
    let orders_head_y = harness
        .query_all_by_label("总量")
        .next()
        .expect("W8:委托表「总量」表头必须查得到")
        .rect()
        .min
        .y;
    let min_x_price = |h: &mut egui_kittest::Harness<'_>| -> egui::Pos2 {
        // `_contains`:点过一次之后表头文字会挂排序箭头(「价格 ▲」),精确匹配就抓不到了。
        h.query_all_by_label_contains("价格")
            .filter(|n| (n.rect().min.y - orders_head_y).abs() < 2.0)
            .min_by(|a, b| {
                a.rect()
                    .min
                    .x
                    .partial_cmp(&b.rect().min.x)
                    .unwrap_or(std::cmp::Ordering::Equal)
            })
            .expect("W8:委托表那一行的「价格」表头必须查得到")
            .rect()
            .center()
    };
    let pos = min_x_price(&mut harness);
    println!("W8 诊断:表头行 y={orders_head_y:.1},点击位置 = {pos:?}");
    click_at(&mut harness, pos, egui::PointerButton::Primary, 1);
    harness.run();
    println!(
        "W8 点表头后 shared.table_sort(\"order_grid\") = {:?}",
        shared.table_sort("order_grid")
    );
    let asc = (y_of(&mut harness, "O-1"), y_of(&mut harness, "O-2"));
    assert!(
        asc.1 < asc.0,
        "W8:点「价格」表头后委托表必须按价格升序(O-2=3.5 到 O-1=101 之上),实测 O-1 y={:.1} O-2 y={:.1}",
        asc.0,
        asc.1
    );
    // 再点一次 → 降序(与成交表同一条 toggle 语义)。
    let pos2 = min_x_price(&mut harness);
    click_at(&mut harness, pos2, egui::PointerButton::Primary, 1);
    harness.run();
    let desc = (y_of(&mut harness, "O-1"), y_of(&mut harness, "O-2"));
    assert!(
        desc.0 < desc.1,
        "W8:再点一次必须翻成降序,实测 O-1 y={:.1} O-2 y={:.1}",
        desc.0,
        desc.1
    );
}

/// 持仓行夹具(W9):三行持仓,数量 5 / 1 / 3,代码 P-1..P-3。
fn w9_position(id: &str, volume: f64) -> ek_data::position::PositionData {
    ek_data::position::PositionData {
        gateway_name: "ctp".to_string(),
        symbol: id.to_string(),
        exchange: ek_data::constant::Exchange::SHFE,
        direction: ek_data::constant::Direction::LONG,
        volume,
        ..ek_data::position::PositionData::default()
    }
}

/// W9 持仓表排序:点「数量」表头 → 行序按持仓量升序。
/// 红证据(0.3.2 上跑):`shared.table_sort("pos_grid")` 仍是 None,行序不动。
#[test]
fn w9_clicking_the_volume_header_sorts_the_positions_table() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = Arc::new(UiShared::new());
    feed_rows(&shared, demo_rows());
    shared.seed_trade_snap(ek_ui::state::TradeSnap {
        positions: vec![
            w9_position("P-1", 5.0),
            w9_position("P-2", 1.0),
            w9_position("P-3", 3.0),
        ],
        ..ek_ui::state::TradeSnap::default()
    });
    let mut harness = harness_for(&shared);
    let hit = ek_ui::fonts::apply_cjk_fonts(&harness.ctx);
    assert!(hit.is_some(), "验收环境必须有 CJK 候选字体");
    harness.run();
    let y_of = |h: &mut egui_kittest::Harness<'_>, id: &str| {
        h.query_all_by_label_contains(id)
            .next()
            .unwrap_or_else(|| panic!("W9:夹具持仓「{id}」必须查得到"))
            .rect()
            .min
            .y
    };
    let before = (y_of(&mut harness, "P-1"), y_of(&mut harness, "P-2"));
    assert!(before.0 < before.1, "W9 前置条件:未排序时按插入序");

    // 锚点:持仓表专属表头「昨仓」(第 6 列),「数量」在它左边且同高。
    let anchor = harness
        .query_all_by_label("昨仓")
        .next()
        .expect("W9:持仓表「昨仓」表头必须查得到")
        .rect();
    let pos = harness
        .query_all_by_label("数量")
        .rfind(|n| (n.rect().min.y - anchor.min.y).abs() < 2.0 && n.rect().min.x < anchor.min.x)
        .expect("W9:持仓表那一行的「数量」表头必须查得到")
        .rect()
        .center();
    click_at(&mut harness, pos, egui::PointerButton::Primary, 1);
    harness.run();
    println!(
        "W9 点表头后 shared.table_sort(\"pos_grid\") = {:?}",
        shared.table_sort("pos_grid")
    );
    let asc = (
        y_of(&mut harness, "P-1"),
        y_of(&mut harness, "P-2"),
        y_of(&mut harness, "P-3"),
    );
    assert!(
        asc.1 < asc.2 && asc.2 < asc.0,
        "W9:点「数量」表头后持仓表必须按持仓量升序(P-2=1 < P-3=3 < P-1=5),实测 y={:?}",
        asc
    );
}

/// W10 行情带排序:点「最新价」表头 → 行序按最新价升序。
/// 红证据(0.3.2 上跑):`shared.table_sort("tick_grid")` 仍是 None,行序不动。
#[test]
fn w10_clicking_the_last_price_header_sorts_the_market_band() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = Arc::new(UiShared::new());
    feed_rows(&shared, demo_rows());
    shared.update_tick(&tick(
        ek_data::constant::Exchange::SHFE,
        "rb2605",
        "螺纹钢2605",
        5.0,
        1.0,
    ));
    shared.update_tick(&tick(
        ek_data::constant::Exchange::SHFE,
        "cu2709",
        "铜2709",
        12345.0,
        2.0,
    ));
    shared.update_tick(&tick(
        ek_data::constant::Exchange::SHFE,
        "au2612",
        "黄金2612",
        98.0,
        3.0,
    ));
    let mut harness = harness_for(&shared);
    let hit = ek_ui::fonts::apply_cjk_fonts(&harness.ctx);
    assert!(hit.is_some(), "验收环境必须有 CJK 候选字体");
    harness.run();
    let y_of = |h: &mut egui_kittest::Harness<'_>, id: &str| {
        h.query_all_by_label_contains(id)
            .next()
            .unwrap_or_else(|| panic!("W10:夹具行情「{id}」必须查得到"))
            .rect()
            .min
            .y
    };
    let before = (y_of(&mut harness, "rb2605"), y_of(&mut harness, "au2612"));
    println!(
        "W10 点表头前:rb2605 y={:.1} au2612 y={:.1}",
        before.0, before.1
    );
    // 前置:行情带缺省按所/symbol 排(不是按价),所以按价升序必然与缺省序不同 ——
    // 判据要的是「点了表头之后 **变了**,且变成价格升序」。
    assert!(
        before.1 < before.0,
        "W10 前置条件:缺省序里 au2612 在 rb2605 之上(按 symbol 排),实测 rb2605 y={:.1} au2612 y={:.1}",
        before.0,
        before.1
    );

    // 锚点:行情带专属表头「今开」(第 6 列),「最新价」在它左边且同高。
    let anchor = harness
        .query_all_by_label("今开")
        .next()
        .expect("W10:行情带「今开」表头必须查得到")
        .rect();
    let pos = harness
        .query_all_by_label_contains("最新价")
        .rfind(|n| (n.rect().min.y - anchor.min.y).abs() < 2.0 && n.rect().min.x < anchor.min.x)
        .expect("W10:行情带那一行的「最新价」表头必须查得到")
        .rect()
        .center();
    click_at(&mut harness, pos, egui::PointerButton::Primary, 1);
    harness.run();
    println!(
        "W10 点表头后 shared.table_sort(\"tick_grid\") = {:?}",
        shared.table_sort("tick_grid")
    );
    let after = (y_of(&mut harness, "rb2605"), y_of(&mut harness, "au2612"));
    let third = y_of(&mut harness, "cu2709");
    assert!(
        after.0 < after.1 && after.1 < third,
        "W10:点「最新价」表头后行情带必须按最新价升序(rb2605=5 < au2612=98 < cu2709=12345),实测 rb2605 y={:.1} au2612 y={:.1} cu2709 y={third:.1}",
        after.0,
        after.1
    );
}

// ===================== Wave E(0.3.2 告警 toast,BD-UI-50)=====================
//
// 判据形状说明(为什么不是 AccessKit):`egui-notify` 的 toast 是 painter 画在
// `LayerId::new(Order::Foreground, Id::new("toasts"))` 上的 —— **没有控件、没有 AccessKit 节点**
// (spike 实核)。所以这一组钉的是**这一帧的绘制指令**:toast 的正文与「▎」级别标记都是
// `Shape::Text`,在 `FullOutput.shapes` 里(图层形状也在其中),按文字内容 + 实际取色 +
// 位置判,不看位图(原来这条是「有告警 vs 无告警」两次渲染数像素带,已撤除)。

/// 右下角(x ≥ 900、y ≥ 500)里含 `needle` 的文字形状,按 y 升序 = 屏上 toast 卡片。
fn toast_texts(shapes: &[egui::Shape], needle: &str) -> Vec<(String, egui::Rect, egui::Color32)> {
    let mut v = texts_containing(shapes, needle)
        .into_iter()
        .filter(|(_, r, _)| r.min.x >= 900.0 && r.min.y >= 500.0)
        .collect::<Vec<_>>();
    v.sort_by(|a, b| a.1.min.y.total_cmp(&b.1.min.y));
    v
}

/// 右下角的「▎」级别标记(一条卡一个),按 y 升序。
fn toast_marks(shapes: &[egui::Shape]) -> Vec<(egui::Rect, egui::Color32)> {
    let mut v = toast_texts(shapes, "▎")
        .into_iter()
        .map(|(_, r, c)| (r, c))
        .collect::<Vec<_>>();
    v.sort_by(|a, b| a.0.min.y.total_cmp(&b.0.min.y));
    v
}

/// V1:界面层灌一条告警 → 右下角必须真的出现 toast(与「没有告警」那一帧取差)。
#[test]
fn e1_an_alert_shows_a_toast_in_the_bottom_right() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let base = {
        let shared = Arc::new(UiShared::new());
        let mut h = harness_for(&shared);
        h.run_steps(6);
        shapes_of(&h)
    };
    let shared = Arc::new(UiShared::new());
    shared.push_alert(ek_ui::toast::AlertLevel::Error, "账户 ct01：掉线");
    let mut harness = harness_for(&shared);
    harness.run_steps(6);
    let shapes = shapes_of(&harness);
    let without = toast_texts(&base, "账户 ct01：掉线");
    let with = toast_texts(&shapes, "账户 ct01：掉线");
    assert!(
        without.is_empty(),
        "V1:没有告警的那一帧不该出现这条 toast,实测 {without:?}"
    );
    assert!(
        !with.is_empty(),
        "V1:告警必须在右下角画出 toast(正文文字形状),实测 {with:?}"
    );
    let marks = toast_marks(&shapes);
    assert!(
        marks.iter().any(|(_, c)| *c == ek_ui::tokens::alert::ERROR),
        "V1:toast 的级别标记「▎」必须是 Python ERROR 色 #FF4D4F,实测 {:?}",
        marks.iter().map(|(_, c)| *c).collect::<Vec<_>>()
    );
}

/// V2:三级色 = Python 那三个,一条都不能少、不能互相串色。
/// 判据 = 右下角「▎」级别标记的实际取色(不是像素带)。
#[test]
fn e2_the_three_levels_use_the_python_colors() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = Arc::new(UiShared::new());
    shared.push_alert(ek_ui::toast::AlertLevel::Info, "甲");
    shared.push_alert(ek_ui::toast::AlertLevel::Warning, "乙");
    shared.push_alert(ek_ui::toast::AlertLevel::Error, "丙");
    let mut harness = harness_for(&shared);
    harness.run_steps(6);
    let marks = toast_marks(&shapes_of(&harness));
    let got: Vec<egui::Color32> = marks.iter().map(|(_, c)| *c).collect();
    for (name, want) in [
        ("INFO #1890FF", ek_ui::tokens::alert::INFO),
        ("WARNING #FAAD14", ek_ui::tokens::alert::WARNING),
        ("ERROR #FF4D4F", ek_ui::tokens::alert::ERROR),
    ] {
        assert!(
            marks.iter().any(|(_, c)| *c == want),
            "V2:{name} 必须有一条 toast 级别标记(右下角「▎」),实测 {got:?}"
        );
    }
    assert_eq!(
        marks.len(),
        3,
        "V2:右下角必须正好三条 toast 标记(实测 {marks:?})"
    );
}

/// V3:右下角向上堆叠,**新的在最底**(Python `_reposition` 的 `reversed()` 口径)。
/// 判据 = 三张卡正文文字形状的 y(不是色带)。
#[test]
fn e3_toasts_stack_upward_with_the_newest_at_the_bottom() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = Arc::new(UiShared::new());
    shared.push_alert(ek_ui::toast::AlertLevel::Info, "最早");
    shared.push_alert(ek_ui::toast::AlertLevel::Warning, "中间");
    shared.push_alert(ek_ui::toast::AlertLevel::Error, "最新");
    let mut harness = harness_for(&shared);
    harness.run_steps(6);
    let shapes = shapes_of(&harness);
    let y_of = |needle: &str| {
        toast_texts(&shapes, needle)
            .into_iter()
            .map(|(_, r, _)| r.min.y)
            .reduce(f32::max)
            .unwrap_or_else(|| panic!("V3:{needle} 那条必须在屏上"))
    };
    let info = y_of("最早");
    let warn = y_of("中间");
    let err = y_of("最新");
    assert!(
        err > warn && warn > info,
        "V3:新的必须在最底 —— 实测 最早 y={info:.1} / 中间 y={warn:.1} / 最新 y={err:.1}"
    );
}

/// V4:同屏上限 3(Python `_max_toasts = 3`;crate 没有上限开关,我们自己关最旧)。
/// 灌 5 条同级别 → 右下角还在屏上的卡片数就是「告警 i」正文文字形状数。
#[test]
fn e4_no_more_than_three_toasts_on_screen() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = Arc::new(UiShared::new());
    for i in 0..5 {
        shared.push_alert(ek_ui::toast::AlertLevel::Error, format!("告警 {i}"));
    }
    let mut harness = harness_for(&shared);
    harness.run_steps(10);
    let seen = toast_texts(&shapes_of(&harness), "告警 ");
    let on_screen: Vec<String> = seen.iter().map(|(t, _, _)| t.clone()).collect();
    assert!(
        !seen.is_empty() && seen.len() <= ek_ui::toast::SCREEN_CAP,
        "V4:屏上 toast 必须 ≤ {} 条(实测 {} 条:{on_screen:?})",
        ek_ui::toast::SCREEN_CAP,
        seen.len()
    );
}

/// V5:机制形状钉(源码扫描)—— 口径不许后来被改回去。
#[test]
fn e5_the_toast_mechanism_keeps_the_python_numbers_and_the_real_trigger() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let read = |f: &str| {
        std::fs::read_to_string(format!("{}/{}", env!("CARGO_MANIFEST_DIR"), f))
            .unwrap_or_else(|_| panic!("{f} 必须可读"))
    };
    let toast_src = read("src/toast.rs");
    assert!(
        toast_src.contains("Duration::from_secs(8)"),
        "V5:自动关必须是 Python 的 8 秒"
    );
    assert!(
        toast_src.contains("Anchor::BottomRight") && toast_src.contains(".reverse(true)"),
        "V5:必须是右下角 + 新的在最底(向上堆叠)"
    );
    assert!(
        toast_src.contains("SCREEN_CAP: usize = 3") && toast_src.contains("dismiss_oldest_toast"),
        "V5:同屏上限 3 与「超限关最旧」必须在这一层里"
    );
    let tokens_src = read("src/tokens.rs");
    assert!(
        tokens_src.contains("0x18, 0x90, 0xFF")
            && tokens_src.contains("0xFA, 0xAD, 0x14")
            && tokens_src.contains("0xFF, 0x4D, 0x4F"),
        "V5:三级色必须是 Python 那三个,而且住在 tokens.rs(单一色源钉 U2)"
    );
    let render_src = read("src/render.rs");
    assert!(
        render_src.contains("crate::toast::drain_and_show"),
        "V5:每帧必须收口 toast 队列(不是某个按钮的副作用)"
    );
    let state_src = read("src/state.rs");
    assert!(
        state_src.contains("self.push_alert(") && state_src.contains("self.alert_once("),
        "V5:必须有一条真告警接在真告警态上(状态轮询回写 + 去重),不许只留一个没人调的 API"
    );
    assert!(
        !render_src.contains("shared.push_alert"),
        "V5(E6 同源):告警不得从某张窗的渲染里产生 —— 账户窗没开也必须知道掉线了"
    );
    let cargo = read("Cargo.toml");
    assert!(
        cargo.contains("egui-notify = \"0.21"),
        "V5:egui-notify 必须锁在 0.21(0.22 起要 egui ^0.34,撞我们的 0.33.3)"
    );
}

// ============ 0.3.3 Wave F:列差集收口(BD-UI-51)的判据钉 ============
//
// 这一组钉的是「**哪一格落在哪一列**」——原来三张表只钉列名在场(s21)与列宽几何(t2/t3),
// 没有钉「表体第 i 格 == 表头第 i 列」。本轮两个真 bug(成交表少一格、持仓表成本/均价取值互换)
// 都是这一条判据的缺口:列名全在场、几何也齐,但内容与表头错位。

/// 全仓唯一的标签 → 那一格的矩形(0 处 / ≥2 处都当场红:0 = 那一格没建构,
/// ≥2 = 撞名或表被建构两遍)。
fn one_rect(harness: &egui_kittest::Harness<'_>, want: &str) -> egui::Rect {
    let hits: Vec<egui::Rect> = harness.query_all_by_label(want).map(|n| n.rect()).collect();
    assert!(
        hits.len() == 1,
        "F 组:「{want}」必须正好一处(0 处 = 那一格没建构,≥2 处 = 撞名或表重复),实测 {}",
        hits.len()
    );
    hits[0]
}

/// 同名标签(代码 / 名称 / 交易所在三张表里都有)在**指定行带 + 指定 x 窗**里的那一格。
fn rect_in_band(
    harness: &egui_kittest::Harness<'_>,
    want: &str,
    band_y: f32,
    left: f32,
    right: f32,
) -> egui::Rect {
    let hits: Vec<egui::Rect> = harness
        .query_all_by_label(want)
        .filter(|n| {
            let r = n.rect();
            (r.center().y - band_y).abs() < 3.0 && r.center().x >= left && r.center().x <= right
        })
        .map(|n| n.rect())
        .collect();
    assert!(
        hits.len() == 1,
        "F 组:行带 y={band_y:.1}、x∈[{left:.1},{right:.1}] 里「{want}」必须正好一处,实测 {}",
        hits.len()
    );
    hits[0]
}

/// 行带过滤版(0.4.1):「交易所」值(SHFE 等)与行情带 tab 头**同名是常态**
/// (六所固定 tab,用户裁定)—— 取「指定行带里的那一格」,0 处 / 多处都红。
fn cell_in_row(harness: &egui_kittest::Harness<'_>, want: &str, row_y: f32) -> egui::Rect {
    let hits: Vec<egui::Rect> = harness
        .query_all_by_label(want)
        .filter(|n| (n.rect().center().y - row_y).abs() < 3.0)
        .map(|n| n.rect())
        .collect();
    assert!(
        hits.len() == 1,
        "F 组:行 y={row_y:.1} 里「{want}」必须正好一处(0 = 格没建构,≥2 = 行带撞名),实测 {}",
        hits.len()
    );
    hits[0]
}

/// 成交行夹具(F1):12 列每列一个**互不相同、全仓唯一**的值 ——
/// 「哪一格在哪一列」在语义树里就数得出来,不靠像素也不靠硬编码区域。
fn f1_trade_row() -> ek_data::trade::TradeData {
    ek_data::trade::TradeData {
        gateway_name: "f1gw".to_string(),
        symbol: "F1SYM".to_string(),
        name: "F1名称".to_string(),
        exchange: ek_data::constant::Exchange::SHFE,
        orderid: "F1ORDER".to_string(),
        tradeid: "F1TRADE".to_string(),
        direction: Some(ek_data::constant::Direction::SHORT),
        offset: ek_data::constant::Offset::CLOSETODAY,
        price: 101.5,
        volume: 7.0,
        traded_amount: 141.25,
        datetime: Some(36_000_000_000_000),
        ..ek_data::trade::TradeData::default()
    }
}

/// F1 成交表「表体第 i 格 == 表头第 i 列」钉(BD-UI-51 的判据本体)。
///
/// 红证据(0.3.2 上跑):成交体表格里**没有「代码」那一格** —— 12 个夹具值里 `F1SYM`
/// 查不到,当场红;补上那一格后,列序仍错(成交号在首列)也红。
#[test]
fn f1_trades_body_cells_line_up_with_their_headers() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    const WANT_HEADERS: [&str; 12] = [
        "代码",
        "名称",
        "交易所",
        "方向",
        "开平",
        "价格",
        "数量",
        "成交金额",
        "时间",
        "成交号",
        "委托号",
        "接口",
    ];
    const WANT_CELLS: [&str; 12] = [
        "F1SYM",
        "F1名称",
        "SHFE",
        "SHORT",
        "CLOSETODAY",
        "101.5",
        "7",
        "141.25",
        "18:00:00.000",
        "F1TRADE",
        "F1ORDER",
        "f1gw",
    ];

    let shared = Arc::new(UiShared::new());
    feed_rows(&shared, demo_rows());
    shared.seed_trade_snap(trades_snap(vec![f1_trade_row()]));
    // 宽夹具(2600×900):两张表都不横向裁剪 → 语义树里没有「被裁掉但矩形伸进别人 x 窗」的杂点。
    let mut harness = Harness::builder()
        .with_size([2600.0, 900.0])
        .build(|ctx| render_body(ctx, &shared));
    let hit = ek_ui::fonts::apply_cjk_fonts(&harness.ctx);
    assert!(hit.is_some(), "验收环境必须有 CJK 候选字体");
    harness.run();

    // ① 12 个值全在场且各一处(少一格就是「表体与表头不同源」——本轮真 bug 的形状)。
    let row_y = one_rect(&harness, "F1TRADE").center().y;

    // ② 表体这一行:按 x 升序读出来的 12 串必须正好是 WANT_CELLS。
    //    (0.4.1:交易所值与行情带 tab 头同名是常态 → 行带过滤版取格。)
    let mut pairs: Vec<(f32, &str)> = WANT_CELLS
        .iter()
        .map(|w| {
            let r = cell_in_row(&harness, w, row_y);
            assert!(
                (r.center().y - row_y).abs() < 3.0,
                "F1:「{w}」必须与成交行同高(y={:.1} vs 行 y={row_y:.1})",
                r.center().y
            );
            (r.center().x, *w)
        })
        .collect();
    pairs.sort_by(|a, b| a.0.partial_cmp(&b.0).unwrap_or(std::cmp::Ordering::Equal));
    let got: Vec<&str> = pairs.iter().map(|(_, l)| *l).collect();
    assert_eq!(
        got,
        WANT_CELLS.to_vec(),
        "F1:成交体表体按 x 升序必须正好是这 12 串(错位 / 少格 / 多格都在这里显形)"
    );

    // ③ 表头:同一行带、成交表自己的 x 窗内,按 x 升序读出来必须正好是 WANT_HEADERS。
    //    为什么这一钉要换一副宽夹具:1280 宽时成交格只有 ~480 px,委托表 17 列**装不下**——
    //    被裁掉的列节点仍在语义树里、矩形却伸到成交表的 x 窗里(实测「时间」在窗内出现两处)。
    //    宽夹具让两张表都不横向裁剪,窗内就只剩成交表自己的 12 个表头。
    //    (判据不假设用户屏幕:这是夹具参数,不是实窗尺寸。)
    let head_y = one_rect(&harness, "成交金额").center().y;
    // x 窗 = 成交表**自己的表头带**(BG4 实心矩形):带就是这张表的身份,天然不含
    // 左列委托表。0.8.5 之前用 F1SYM.min.x−60 的松量,撤列后左列「接口」表头
    // 只剩 5 px 就会漏进窗(实测 2 处)—— 改吃带边界,判据不再依赖列数巧合。
    let shapes_hdr = shapes_of(&harness);
    let trade_band = header_bands(&shapes_hdr, ek_ui::tokens::shadcn::BG4, 100.0)
        .into_iter()
        .find(|b| b.min.y < head_y + 3.0 && b.max.y > head_y - 3.0 && b.min.x > 600.0)
        .expect("成交表必须有表头带(BG4);未找到 = 表头带回归或布局退列");
    let (left, right) = (trade_band.min.x + 2.0, trade_band.max.x - 2.0);
    let mut head: Vec<(f32, &str)> = WANT_HEADERS
        .iter()
        .map(|h| {
            (
                rect_in_band(&harness, h, head_y, left, right).center().x,
                *h,
            )
        })
        .collect();
    head.sort_by(|a, b| a.0.partial_cmp(&b.0).unwrap_or(std::cmp::Ordering::Equal));
    let got_head: Vec<&str> = head.iter().map(|(_, l)| *l).collect();
    assert_eq!(
        got_head,
        WANT_HEADERS.to_vec(),
        "F1:成交表表头行带内按 x 升序必须正好是这 12 列(每一列都在窗内正好一处)"
    );
}

/// F2 持仓表「成本 / 均价」取值钉:Python 是 成本 ← `avg_price`、均价 ← `price`
/// (`widget.py:1491-1492`;ek-data `position.rs:22-23 / 38-39` 同口径)。
/// 红证据(0.3.2 上跑):渲染侧这两格**取值互换** —— 成本格里印的是 `price`。
#[test]
fn f2_position_cost_and_average_price_are_not_swapped() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = Arc::new(UiShared::new());
    feed_rows(&shared, demo_rows());
    shared.seed_trade_snap(ek_ui::state::TradeSnap {
        positions: vec![ek_data::position::PositionData {
            gateway_name: "ctp".to_string(),
            symbol: "F2SYM".to_string(),
            exchange: ek_data::constant::Exchange::SHFE,
            direction: ek_data::constant::Direction::LONG,
            volume: 3.0,
            yd_volume: 1.0,
            can_use_volume: 2.0,
            frozen: 1.0,
            on_road_volume: 4.0,
            market_value: 555.0,
            price: 101.5,
            avg_price: 98.25,
            last_price: 77.125,
            pnl: -6.5,
            profit_rate: 1.5,
            name: "F2名称".to_string(),
        }],
        ..ek_ui::state::TradeSnap::default()
    });
    // 宽夹具(BD-UI-55):「77.125」是持仓表最后一列(最新价)的值,1280 宽时那一列在
    // 横向裁剪外,egui_table 不建构裁剪外的格 → 读不到(见 `harness_wide_for`)。
    let mut harness = harness_wide_for(&shared);
    let hit = ek_ui::fonts::apply_cjk_fonts(&harness.ctx);
    assert!(hit.is_some(), "验收环境必须有 CJK 候选字体");
    harness.run();

    let body_y = one_rect(&harness, "F2SYM").center().y;
    let cost_v = one_rect(&harness, "98.25");
    let avg_v = one_rect(&harness, "101.5");
    for (label, r) in [("98.25", &cost_v), ("101.5", &avg_v)] {
        assert!(
            (r.center().y - body_y).abs() < 3.0,
            "F2:「{label}」必须与持仓行同高(y={:.1} vs 行 y={body_y:.1})",
            r.center().y
        );
    }
    // 列带:成本表头 → 均价表头 之间 = 成本列;均价 → 盈亏 之间 = 均价列。
    // (0.8.5 撤死列:「最新价」列已不在持仓表,f2 右锚改「盈亏」;「最新价」
    // 在行情带表头里也有,当初靠 y 区分的那段麻烦随之消失。)
    let head_y = one_rect(&harness, "成本").center().y;
    let band = |label: &str| {
        rect_in_band(&harness, label, head_y, f32::MIN, f32::MAX)
            .center()
            .x
    };
    let (cost_h, avg_h, pnl_h) = (band("成本"), band("均价"), band("盈亏"));
    assert!(
        cost_h < avg_h && avg_h < pnl_h,
        "F2:持仓表表头 x 序必须是 成本 < 均价 < 盈亏,实测 {cost_h:.1} / {avg_h:.1} / {pnl_h:.1}"
    );
    assert!(
        cost_h < cost_v.center().x && cost_v.center().x < avg_h,
        "F2:成本列必须装 `avg_price`(98.25):成本表头 x={cost_h:.1} 均价表头 x={avg_h:.1},值 x={:.1}",
        cost_v.center().x
    );
    assert!(
        avg_h < avg_v.center().x && avg_v.center().x < pnl_h,
        "F2:均价列必须装 `price`(101.5):均价表头 x={avg_h:.1} 盈亏表头 x={pnl_h:.1},值 x={:.1}",
        avg_v.center().x
    );
    // 盈亏负数必须显形(Python PnlCell:句首是 `-` 就染空色,这里钉的是「那一格在不在」)。
    let _ = one_rect(&harness, "-6.5");
}

/// F3 成交表列序钉(源码机械扫):列头字面量必须就是 Python `TradeMonitor.headers` 那 12 列。
/// 判据形状选源码扫描而不是语义树,是因为 F1 已经钉了「表体与表头同源」——
/// 这一条钉的是**序本身**(F1 只核「表头与表体一致」,两边一起换序 F1 挡不住)。
#[test]
fn f3_trades_column_order_matches_the_python_blueprint() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let render = std::fs::read_to_string(concat!(env!("CARGO_MANIFEST_DIR"), "/src/render.rs"))
        .expect("render.rs 必须可读");
    let want = [
        "代码",
        "名称",
        "交易所",
        "方向",
        "开平",
        "价格",
        "数量",
        "成交金额",
        "时间",
        "成交号",
        "委托号",
        "接口",
    ];
    // 只切 `TRADE_HEADERS` 那一个字面量块再比 —— 不能在整个文件里做「子序列查找」:
    // 本轮自查实撞:那样写时把「代码/名称」对调,F3 照样绿(它命中的是更靠前的 ORDER_HEADERS),
    // 等于这条钉没钉住任何东西。切块之后错序当场红。
    let anchor = "const TRADE_HEADERS: [&str; 12] = [";
    let start = render.find(anchor).unwrap_or_else(|| {
        panic!("F3:成交表列头必须是单源常量 `{anchor}`(12 列),不许两处各写一份")
    });
    let block = &render[start + anchor.len()..];
    let end = block
        .find("];")
        .unwrap_or_else(|| panic!("F3:TRADE_HEADERS 字面量必须闭合(找不到 `];`)"));
    // 逐个取出块里的字符串字面量(顺序即列序)。
    let got: Vec<String> = block[..end]
        .split('"')
        .enumerate()
        .filter(|(i, _)| i % 2 == 1)
        .map(|(_, s)| s.to_string())
        .collect();
    assert_eq!(
        got,
        want.iter().map(|s| s.to_string()).collect::<Vec<_>>(),
        "F3:TRADE_HEADERS 的列序必须逐字等于 Python TradeMonitor.headers(widget.py:1270-1283)"
    );
}

/// F4 展示格式单一口径钉(BD-UI-49 的收口尾巴):`render.rs` 里不许再有带精度的裸 `format!`。
/// 排序键(`{:020.4}` / `{ns:025}`)不是展示格式,不在这条口径内。
#[test]
fn f4_display_formats_live_only_in_format_rs() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let render = std::fs::read_to_string(concat!(env!("CARGO_MANIFEST_DIR"), "/src/render.rs"))
        .expect("render.rs 必须可读");
    for needle in ["format!(\"{:", "format!(\"{ns:"] {
        let hits: Vec<&str> = render
            .lines()
            .filter(|l| {
                let t = l.trim_start();
                // 注释里出现 `format!("{:.2}")` 是**说明**不是口径,不算违规。
                !t.starts_with("//")
                    && l.contains(needle)
                    && !l.contains("020.4")
                    && !l.contains("025}")
            })
            .map(str::trim)
            .collect();
        assert!(
            hits.is_empty(),
            "F4:render.rs 里不许有带精度的裸 format 展示格式(只许走 src/format.rs),实测 {hits:?}"
        );
    }
    // 上面两条子串只认 `{:...`(无名参数);命名参数 `format!("{price:.2}")` 会从子串里漏过去。
    // 所以再走一遍说明符级扫描:带精度(`.`) / 符号(`+`) / 对齐(`>`)的说明符一律算展示格式,
    // 只放行排序键那三支零填充。
    let mut offenders: Vec<String> = Vec::new();
    for line in render.lines() {
        if line.trim_start().starts_with("//") || !line.contains("format!(\"") {
            continue;
        }
        for spec in line.split('{').skip(1) {
            let Some(close) = spec.find('}') else {
                continue;
            };
            let spec = &spec[..close];
            let is_sort_key = spec == ":020.4" || spec == "ns:025" || spec == ":025";
            let is_display = spec.contains('.') || spec.contains('+') || spec.contains('>');
            if is_display && !is_sort_key {
                offenders.push(format!("{{{spec}}} in: {}", line.trim()));
            }
        }
    }
    assert!(
        offenders.is_empty(),
        "F4:render.rs 里不许有带精度/符号/对齐的裸 format 展示格式(只许走 src/format.rs),实测 {offenders:?}"
    );
    let fmt = std::fs::read_to_string(concat!(env!("CARGO_MANIFEST_DIR"), "/src/format.rs"))
        .expect("format.rs 必须可读");
    for name in [
        "pub fn price(",
        "pub fn volume(",
        "pub fn pct(",
        "pub fn price_tick(",
        "pub fn time_hms_millis(",
        "pub fn date_ymd(",
    ] {
        assert!(
            fmt.contains(name),
            "F4:展示口径必须齐这六支(缺一支就会有人回到裸 format!),缺 {name}"
        );
    }
    // 涨跌幅与最小变动价位是**显式登记的有意偏离**(带符号两位 / 固定四位),
    // 判据钉「偏离写在 format.rs 里」而不是假装与 Python 一致。
    assert!(
        fmt.contains("pub fn pct(") && fmt.contains("pub fn price_tick("),
        "F4:两支偏离口径必须住在 format.rs 并带注释,不许散回 render.rs"
    );
}

/// s87(0.4.4,P5-a 裁定):运维窗「oms 管线」节 —— 装配显形有出口了。
///
/// 插件表给「谁在场」,这一节给「oms 里面装了什么」。判据两半:有读数就画(标题 +
/// 逐行),没读数就**整节不画**(不是画一个空表 —— 这一节没有表、没有可空的东西,
/// 与六期 BD-UI-59 不是同一种空)。内容本身在 tests/ui_ops.rs 的 t3 真链钉里判。
#[test]
fn s87_ops_window_shows_oms_pipeline_section_when_present() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = Arc::new(UiShared::new());
    feed_rows(
        &shared,
        vec![row("svctl"), row("dm"), row("oms"), row("ui")],
    );
    shared.set_pipeline_lines(vec![
        "stage:validate|split|risk|send|book".to_string(),
        "floor:field|rate(5/s)|cancel-guard(3)".to_string(),
        "splitter:ek-converter".to_string(),
        "gate:ek-risk:contract".to_string(),
        "gate:ek-risk:price-band".to_string(),
    ]);
    shared.set_ops_window_open(true);
    let mut harness = harness_for(&shared);
    harness.run();

    assert!(
        harness
            .query_all_by_label_contains("oms 管线")
            .next()
            .is_some(),
        "有读数必须有小节标题"
    );
    for needle in [
        "stage:validate|split|risk|send|book",
        "floor:field|rate(5/s)|cancel-guard(3)",
        "gate:ek-risk:contract",
        "gate:ek-risk:price-band",
    ] {
        assert!(
            harness.query_all_by_label_contains(needle).next().is_some(),
            "装配行 {needle} 没上屏"
        );
    }
}

/// s87b(同一钉的反向半):问不到 = 整节不画。
#[test]
fn s87b_ops_window_omits_oms_pipeline_section_when_absent() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = Arc::new(UiShared::new());
    feed_rows(&shared, vec![row("svctl"), row("dm"), row("ui")]);
    // 没有 oms:ask 走 TargetGone 快错 → 读数是空的(与真链 plugin.rs 的 Err 分支同形)。
    shared.set_pipeline_lines(Vec::new());
    shared.set_ops_window_open(true);
    let mut harness = harness_for(&shared);
    harness.run();

    assert!(
        harness
            .query_all_by_label_contains("oms 管线")
            .next()
            .is_none(),
        "没读数时整节不许画(空标题比没有更坏)"
    );
    assert!(
        harness
            .query_all_by_label_contains("stage:validate")
            .next()
            .is_none(),
        "同上:内容也不许残留"
    );
}

/// s88(0.5 M3):装配显形改吃事件之后,运维窗留一个手动口子,而且它是接线的。
///
/// 判据两半:钮在场(而且是在**没有读数**的那一帧里也在 —— 恰恰问不到的时候最需要重问,
/// 所以钮挂在「插件」节而不是「oms 管线」节),并且点下去真的置了标记(状态效果,
/// 不是只画了个钮)。
#[test]
fn s88_ops_window_has_a_wired_manual_pipeline_reask() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = Arc::new(UiShared::new());
    feed_rows(&shared, vec![row("svctl"), row("dm"), row("ui")]);
    shared.set_pipeline_lines(Vec::new());
    shared.set_ops_window_open(true);
    let mut harness = harness_for(&shared);
    harness.run();

    let pos = {
        let node = harness
            .query_all_by_label_contains(ek_ui::render::BTN_PIPELINE_REFRESH)
            .next()
            .unwrap_or_else(|| {
                panic!(
                    "s88:没读数时也要有『{}』钮(问不到才最需要重问)",
                    ek_ui::render::BTN_PIPELINE_REFRESH
                )
            });
        node.rect().center()
    };
    click_at(&mut harness, pos, egui::PointerButton::Primary, 1);
    harness.run();
    assert!(
        shared.take_pipeline_due(),
        "点钮必须置「该问一次」标记(消费性标记,不是一档状态)"
    );
    assert!(
        !shared.take_pipeline_due(),
        "一次点击只标记一次,不许留成常驻"
    );
}

// ================= 0.8.0 配色双档落屏判据(BD-UI-61,s89–s93) =================
//
// 这五条钉问的是「**画面**真的跟着档走」,不是「令牌里有两支色」:
// 全部走 kittest 形状/语义树(不出图、不比像素截图),浅色档由 `shared.set_theme`
// 装进夹具 —— 夹具跑的就是 `render_body`,所以换一档 = 整帧换档。

/// 两档整帧钉:同一套夹具数据,深档帧画得出深档底/带底/行线,浅档帧画得出浅档那三支,
/// 且**互不出现**(浅档帧里还留着深档底 = 渲染侧把深档常量写死了)。
#[test]
fn s89_both_palettes_land_on_screen_frame_wide() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = Arc::new(UiShared::new());
    feed_rows(&shared, demo_rows());
    shared.update_tick(&tick(
        ek_data::constant::Exchange::SHFE,
        "rb2605",
        "螺纹钢2605",
        101.0,
        1.25,
    ));
    let dark = harness_wide_for(&shared);
    assert!(
        ek_ui::fonts::apply_cjk_fonts(&dark.ctx).is_some(),
        "验收环境必须有 CJK 候选字体"
    );
    let dshapes = shapes_of(&dark);
    assert!(
        !filled_rects(&dshapes, ek_ui::tokens::PALETTE_DARK.bg4).is_empty(),
        "深档帧里必须有表头带底"
    );
    assert!(
        !hlines(&dshapes, ek_ui::tokens::PALETTE_DARK.border_soft).is_empty(),
        "深档帧里必须画得出行线"
    );
    shared.set_theme(ek_ui::tokens::Theme::Light);
    let light = harness_wide_for(&shared);
    assert!(
        ek_ui::fonts::apply_cjk_fonts(&light.ctx).is_some(),
        "验收环境必须有 CJK 候选字体"
    );
    let lshapes = shapes_of(&light);
    assert!(
        !filled_rects(&lshapes, ek_ui::tokens::PALETTE_LIGHT.bg4).is_empty(),
        "浅档帧里必须有浅档表头带底"
    );
    assert!(
        !hlines(&lshapes, ek_ui::tokens::PALETTE_LIGHT.border_soft).is_empty(),
        "浅档帧里必须画得出浅档行线"
    );
    let stray_band: Vec<egui::Rect> = filled_rects(&lshapes, ek_ui::tokens::PALETTE_DARK.bg4);
    assert!(
        stray_band.is_empty(),
        "浅档帧里不许出现深档带底,实测 {n} 块",
        n = stray_band.len()
    );
    let stray_bg: Vec<egui::Rect> = filled_rects(&lshapes, ek_ui::tokens::PALETTE_DARK.bg1);
    println!("S89 探针 浅档帧里的深档底矩形 = {stray_bg:?}");
    assert!(
        stray_bg.is_empty(),
        "浅档帧里不许出现深档页面底,实测 {n} 块",
        n = stray_bg.len()
    );
    // 语义色也照档走:涨行的涨跌幅在浅档帧里必须是浅档那支涨色,不许还是深档那支。
    let rise_light = ek_ui::tokens::semantic_of_theme(ek_ui::tokens::Theme::Light).rise;
    let rise_dark = ek_ui::tokens::semantic_of_theme(ek_ui::tokens::Theme::Dark).rise;
    assert_ne!(rise_light, rise_dark, "夹具前提:两档涨色必须不同值");
    let lit = text_shapes_of_color(&lshapes, rise_light);
    let dk = text_shapes_of_color(&lshapes, rise_dark);
    assert!(
        !lit.is_empty() && dk.is_empty(),
        "浅档帧里的涨色必须是浅档那支(浅档支 {n1} 处 / 深档支 {n2} 处)",
        n1 = lit.len(),
        n2 = dk.len()
    );
}

/// 表头带底与描边两支不互吃(BD-UI-57 拆开的那两支在**浅档**里也要成立):
/// 浅档两支都是浅灰,一支兼两职 = 表头带与行线糊成一片,这条最容易被"顺手合回去"。
#[test]
fn s90_band_fill_and_border_stay_two_colors_in_light_theme() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let pal = ek_ui::tokens::PALETTE_LIGHT;
    assert_ne!(
        pal.bg4, pal.border,
        "浅档带底与描边同值 = 一支兼两职(带与行线糊在一起)"
    );
    let shared = Arc::new(UiShared::new());
    feed_rows(&shared, demo_rows());
    shared.set_theme(ek_ui::tokens::Theme::Light);
    let harness = harness_wide_for(&shared);
    assert!(
        ek_ui::fonts::apply_cjk_fonts(&harness.ctx).is_some(),
        "验收环境必须有 CJK 候选字体"
    );
    let shapes = shapes_of(&harness);
    let bands = filled_rects(&shapes, pal.bg4);
    let lines = hlines(&shapes, pal.border);
    assert!(!bands.is_empty(), "浅档帧里必须画得出表头带底");
    assert!(!lines.is_empty(), "浅档帧里必须画得出行线");
    // 「互吃」的两种机械形状都数一遍:
    // ① 描边那支被拿去当**实心填充**(带底)—— 带底色必须只有 bg4 那一支;
    // ② 带底那支被拿去画**行线** —— 行线色必须只有 border 那一支。
    let border_as_fill: Vec<egui::Rect> = filled_rects(&shapes, pal.border);
    assert!(
        border_as_fill.is_empty(),
        "浅档里描边那支不许当实心填充(一支兼两职),实测 {n} 块",
        n = border_as_fill.len()
    );
    let band_as_line: Vec<(f32, egui::Rangef)> = hlines(&shapes, pal.bg4);
    assert!(
        band_as_line.is_empty(),
        "浅档里带底那支不许当行线(一支兼两职),实测 {n} 条",
        n = band_as_line.len()
    );
}

/// 逐列左沿对齐(裁定 D + 表头吃格内边距):表头文字左边界必须与该列表体格左边界
/// 落在同一 x(±1 px),逐列核 —— 用户报的「表头和表的内容对齐方式不一致」就钉在这。
#[test]
fn s91_header_and_body_cells_share_the_left_edge_per_column() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = Arc::new(UiShared::new());
    feed_rows(&shared, demo_rows());
    let _ = seed_md_source(&shared, "9999", "278153");
    shared.update_contract(&contract(
        ek_data::constant::Exchange::SHFE,
        "rb2605",
        "螺纹钢2605",
    ));
    shared.set_contracts_window_open(true);
    let harness = harness_wide_for(&shared);
    assert!(
        ek_ui::fonts::apply_cjk_fonts(&harness.ctx).is_some(),
        "验收环境必须有 CJK 候选字体"
    );
    // 合约表(CONTRACT_HEADERS 五列)逐列核:表头左沿 vs 该列第一格左沿。
    // 表头标签全仓唯一;表体格取「表头下方 60px 内」的那一颗(避开同名串在别的表里)。
    for (header, body) in [("交易所", "SHFE"), ("乘数", "10"), ("最小变动", "1.0000")] {
        // 表体格:合约表只喂一行 → 全帧里这颗就是它(夹具前提:同名串必须恰好一颗)。
        let cells: Vec<egui::Rect> = harness.query_all_by_label(body).map(|n| n.rect()).collect();
        assert_eq!(
            cells.len(),
            1,
            "夹具前提:表体格「{body}」全帧必须恰好一颗(合约表只喂一行),实测 {n} 颗",
            n = cells.len()
        );
        let cell = cells[0];
        // 同名表头在全帧有多处(行情带/委托/成交表都有「交易所」)→ 取**该格正上方最近**那颗
        // = 拥有这一列的那张表的表头。
        let heads: Vec<egui::Rect> = harness
            .query_all_by_label(header)
            .map(|n| n.rect())
            .filter(|r| r.max.y <= cell.min.y)
            .collect();
        assert!(
            !heads.is_empty(),
            "「{body}」这一列上方必须有表头「{header}」"
        );
        let head = heads
            .iter()
            .max_by(|a, b| {
                a.min
                    .y
                    .partial_cmp(&b.min.y)
                    .unwrap_or(std::cmp::Ordering::Equal)
            })
            .copied()
            .expect("取最近的一颗表头");
        assert!(
            (head.min.x - cell.min.x).abs() <= 1.0,
            "列「{header}」表头左沿 x={:.1} 与表体左沿 x={:.1} 不同一条竖线(差 {:.1}px)",
            head.min.x,
            cell.min.x,
            (head.min.x - cell.min.x).abs()
        );
    }
}

/// 等宽数字落屏(撤右对齐之后,「数字成列」全押这条);反向半条:非数字格不许被顺手做等宽。
#[test]
fn s92_numeric_cells_render_monospace_and_only_numbers() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = Arc::new(UiShared::new());
    feed_rows(&shared, demo_rows());
    shared.seed_trade_snap(trades_snap(vec![trade_row("P1", 102.5, "螺纹钢2605")]));
    shared.update_tick(&tick(
        ek_data::constant::Exchange::SHFE,
        "rb2605",
        "螺纹钢2605",
        101.0,
        1.25,
    ));
    let harness = harness_wide_for(&shared);
    assert!(
        ek_ui::fonts::apply_cjk_fonts(&harness.ctx).is_some(),
        "验收环境必须有 CJK 候选字体"
    );
    for s in ["101", "102.5"] {
        let at = harness
            .query_all_by_label(s)
            .map(|n| n.rect())
            .next()
            .unwrap_or_else(|| panic!("必须有数字格「{s}」"));
        assert!(
            monospace_at(&harness, s, &at)
                .unwrap_or_else(|| panic!("必须有「{s}」的文字形状(数字格没上屏)")),
            "数字格「{s}」必须走等宽字体(全左对齐后「成列」全靠它)"
        );
    }
    let at = harness
        .query_all_by_label("螺纹钢2605")
        .map(|n| n.rect())
        .next()
        .expect("行情带必须有名称格");
    assert!(
        !monospace_at(&harness, "螺纹钢2605", &at).unwrap_or(true),
        "名称格不许走等宽(等宽只给数字格)"
    );
}

/// K 线跟档(0.8.0 补的图表三支):同一份 K 线夹具,深档帧画得出深档底,浅档帧必须换成
/// 浅档底且不留深档底 —— 旧写法直写深档常量,K 线是浅档界面里唯一一块黑底
/// (`s10` 钉源码字面形状,这条钉画面)。
#[test]
fn s93_kline_chart_follows_the_current_theme() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = Arc::new(UiShared::new());
    feed_rows(&shared, demo_rows());
    feed_market_frame(&shared, 2, 4);
    shared.open_kline("rb2605");
    let dark = harness_wide_for(&shared);
    assert!(
        ek_ui::fonts::apply_cjk_fonts(&dark.ctx).is_some(),
        "验收环境必须有 CJK 候选字体"
    );
    let dshapes = shapes_of(&dark);
    assert!(
        !filled_rects(&dshapes, ek_ui::tokens::PALETTE_DARK.bg1).is_empty(),
        "深档 K 线帧必须画得出深档底"
    );
    shared.set_theme(ek_ui::tokens::Theme::Light);
    let light = harness_wide_for(&shared);
    assert!(
        ek_ui::fonts::apply_cjk_fonts(&light.ctx).is_some(),
        "验收环境必须有 CJK 候选字体"
    );
    let lshapes = shapes_of(&light);
    assert!(
        !filled_rects(&lshapes, ek_ui::tokens::PALETTE_LIGHT.bg1).is_empty(),
        "浅档 K 线帧必须画得出浅档底(写死深档常量 = 界面里唯一一块黑底)"
    );
    let stray: Vec<egui::Rect> = filled_rects(&lshapes, ek_ui::tokens::PALETTE_DARK.bg1);
    assert!(
        stray.is_empty(),
        "浅档帧不许留深档底(K 线区最容易漏),实测 {n} 块",
        n = stray.len()
    );
    let rise_light = ek_ui::tokens::semantic_of_theme(ek_ui::tokens::Theme::Light).rise;
    let rise_dark = ek_ui::tokens::semantic_of_theme(ek_ui::tokens::Theme::Dark).rise;
    assert_ne!(rise_light, rise_dark, "夹具前提:两档涨色必须不同值");
    let lit = any_shapes_of_color(&lshapes, rise_light);
    let dk = any_shapes_of_color(&lshapes, rise_dark);
    assert!(
        !lit.is_empty() && dk.is_empty(),
        "浅档帧的涨色必须是浅档那支(浅档支 {n1} 处 / 深档支 {n2} 处)",
        n1 = lit.len(),
        n2 = dk.len()
    );
}

/// **s94(0.8.2)—— 三层文字色必须各自落屏(落屏钉,不是字段钉)。**
///
/// 0.8.0 的教训:`Chrome.header_text = text3` 与 `PALETTE.text2` 当时都在、也被钉过,
/// 但六张表的表头是 `header_cell_ui` 自己画字、**没吃 header_text**,普通 label 又全吃
/// `text1` → 屏幕上表头/表体/正文一个色(用户复看:「表头和表格里的字的颜色就不对」)。
/// 钉在色板字段上救不了这一条,**只有量到本帧文字的着色才测得到**。
#[test]
fn s94_text_ladder_lands_on_screen_in_both_themes() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = Arc::new(UiShared::new());
    feed_rows(&shared, demo_rows());
    shared.update_tick(&tick(
        ek_data::constant::Exchange::SHFE,
        "rb2605",
        "螺纹钢2605",
        101.0,
        1.25,
    ));
    let color_of_first = |h: &Harness<'_>, needle: &str| -> Option<egui::Color32> {
        for shape in shapes_of(h) {
            if let egui::Shape::Text(t) = shape
                && t.galley.text().contains(needle)
            {
                return Some(text_color_of(&t));
            }
        }
        None
    };
    for theme in [ek_ui::tokens::Theme::Dark, ek_ui::tokens::Theme::Light] {
        shared.set_theme(theme);
        let h = harness_wide_for(&shared);
        assert!(
            ek_ui::fonts::apply_cjk_fonts(&h.ctx).is_some(),
            "验收环境必须有 CJK 候选字体"
        );
        let pal = theme.palette();
        // ① 表头 = 次级色(参考站 th{color:var(--st-ink-muted)})
        let head = color_of_first(&h, "最新价").expect("行情带表头「最新价」必须落屏");
        assert_eq!(
            head, pal.text3,
            "{theme:?} 档表头文字必须落 text3(参考 th = ink-muted),实测 {head:?}"
        );
        // ② 表体数字 = 表体色(参考站 td{color:var(--st-ink-soft)})
        let body = color_of_first(&h, "1234").expect("行情带表体数字必须落屏");
        assert_eq!(
            body, pal.text2,
            "{theme:?} 档表体数字必须落 text2(参考 td = ink-soft),实测 {body:?}"
        );
        // ③ 控件/强文字层 = 正文色(参考站 ink)
        let ink = h.ctx.style().visuals.strong_text_color();
        assert_eq!(ink, pal.text1, "{theme:?} 档强文字层必须 = text1");
        // ④ 三层不许塌:三个落点两两不等
        assert_ne!(head, body, "{theme:?} 档表头与表体同色 = 层级塌一档");
        assert_ne!(head, ink, "{theme:?} 档表头与正文同色 = 层级塌一档");
        assert_ne!(body, ink, "{theme:?} 档表体与正文同色 = 层级塌一档");
    }
    shared.set_theme(ek_ui::tokens::Theme::Dark);
}

/// 复原行上屏钉(0.9.0,BD-APP-1):临时档案根摆一档 → 启动清点 → 账户面板
/// 打开后,行带「〔档案·密库引用 ✓〕」徽标、「自动连」勾选在场;**密码值与
/// `secret://` 形态的引用串都不为语义树所见**(不回显口径的界面面证据)。
#[test]
fn s58_restored_row_renders_archive_badge_and_auto_connect_toggle() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = Arc::new(UiShared::new());
    // 临时档根(crate 内 target/tmp;真库零接触 —— 同 ui_restore 判据面纪律)。
    let root = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"))
        .join("target")
        .join("tmp")
        .join(format!("ekui-kit-restore-{}", std::process::id()));
    let _ = std::fs::remove_dir_all(&root);
    let store = ek_cfg::Store::with_root(root.clone());
    let acct = ek_core::SectionMap::new(1)
        .set("broker_id", ek_core::Field::plain("9"))
        .set("td_addr", ek_core::Field::plain("tcp://1.2.3.4:40001"))
        .set("td_user", ek_core::Field::plain("11"))
        .set("td_app_id", ek_core::Field::plain("simnow_client_test"))
        .set("td_auth_code", ek_core::Field::plain("0123456789abcdef"))
        .set("product_classes", ek_core::Field::plain("1"))
        .set("td_password", ek_core::Field::secret("gw_td_password"));
    ek_cfg::cfg_save_at(store.root(), "ctp.ctp_9_11", &acct).expect("临时档案");
    let restored = shared.restore_saved_accounts_from(&store);
    assert_eq!(restored, vec!["ctp_9_11".to_string()]);

    shared.set_accounts_window_open(true);
    let mut harness = harness_for(&shared);
    harness.run();

    assert!(
        harness.query_by_label("ctp_9_11").is_some(),
        "复原行派生名必须落屏(账户 Grid 第一列)"
    );
    assert!(
        harness
            .query_all_by_label_contains("档案")
            .next()
            .is_some(),
        "档案徽标(0.9.10 二字徽标,说明进悬停 tooltip)必须落屏 —— 密码值的替身只许有这一档"
    );
    assert!(
        harness
            .query_all_by_label_contains("tcp://1.2.3.4:40001")
            .next()
            .is_some(),
        "td 前置整串直显(0.9.10 用户裁定:配了什么 IP/端口就要显示)"
    );
    assert!(
        harness
            .query_all_by_label_contains("自动连")
            .next()
            .is_some(),
        "「自动连」勾选必须给档案行与手输行共用(启动清点面 = 守护/桌面的开关源)"
    );
    assert!(
        harness
            .query_all_by_label_contains("secret://")
            .next()
            .is_none(),
        "引用串形态(secret://…)不得进语义树:密码值的替身是徽标,不是引用串"
    );
    let _ = std::fs::remove_dir_all(&root);
}

/// s90(0.9.10 用户裁定「一账号多套前置,别名备注切换」的界面面钉):
/// 同 broker+账号,td 前置不同 → 两行共存,第二行自动后缀 `_2`;
/// td 前置列把两根 IP:端口并排显形;别名各贴各的(挑行 = 挑标签)。
#[test]
fn s90_multi_front_same_account_two_rows() {
    ek_cfg::set_default_root_for_tests(std::path::PathBuf::from("C:/dev/fuke/ek-ui/target/cfg-test-root"));
    let shared = Arc::new(UiShared::new());
    feed_rows(&shared, demo_rows());
    shared.set_accounts_window_open(true);
    let mut harness = harness_for(&shared);
    harness.run();
    // 第一套:278153 @ :30001。
    add_via_dialog(
        &mut harness,
        &shared,
        acct_form("9999", "278153", "tcp://182.254.243.31:30001", "tcp://182.254.243.31:30011"),
    );
    let _ = shared.drain_cmds();
    // 第二套:同账号 @ :40001(同 IP 换端口 = 用户点名的口径)。
    click_account_add(&mut harness);
    harness.run();
    shared.set_ctp_form(ek_ui::state::CtpForm {
        td_user: "278153".to_string(),
        td_addr: "tcp://182.254.243.31:40001".to_string(),
        td_password: "pw-2".to_string(),
        md_addr: "tcp://182.254.243.31:40011".to_string(),
        ..shared.ctp_form()
    });
    harness.run();
    click_dialog(&mut harness, "保存");
    let _ = shared.drain_cmds();
    assert_eq!(shared.accounts().len(), 2, "同账号两套前置 = 两行共存");
    assert!(
        shared
            .accounts()
            .iter()
            .any(|a| a.gateway == "ctp_9999_278153_2"),
        "第二行 = 后缀 _2(基名零迁移)"
    );
    harness.run();
    assert!(
        row_action_exists(&harness, "ctp_9999_278153_2", "连接"),
        "_2 行独立给『连接』(用户挑一行登)"
    );
    assert_eq!(
        harness
            .query_all_by_label_contains("tcp://182.254.243.31:")
            .count(),
        2,
        "td 前置列并排显形两根前置(哪套挂哪行一眼看穿)"
    );
    // 同 broker+账号+前置三全同重加 = 弹窗拦(不产生第三行)。
    click_account_add(&mut harness);
    harness.run();
    shared.set_ctp_form(ek_ui::state::CtpForm {
        td_user: "278153".to_string(),
        td_addr: "tcp://182.254.243.31:40001".to_string(),
        td_password: "pw-3".to_string(),
        ..shared.ctp_form()
    });
    harness.run();
    click_dialog(&mut harness, "保存");
    assert_eq!(
        shared.accounts().len(),
        2,
        "三全同前置必须被拦(清册不增行)"
    );
    assert!(shared.account_edit_open(), "被拦不得关弹窗(就地改前置)");
    click_dialog(&mut harness, "取消");
}