pythonocc-step-editor/scripts/verify_property_card_editor_ui.py

from __future__ import annotations

import json
import math
import os
from pathlib import Path
import sys
import tempfile

os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")

from PySide6.QtCore import QEvent, QObject, Qt, QStringListModel
from PySide6.QtGui import QKeyEvent
from PySide6.QtTest import QTest
from PySide6.QtWidgets import (
    QApplication,
    QCheckBox,
    QCompleter,
    QFrame,
    QHBoxLayout,
    QLabel,
    QLineEdit,
    QListWidget,
    QPushButton,
    QScrollArea,
    QTableWidget,
    QTableWidgetItem,
    QVBoxLayout,
    QWidget,
)

PROJECT_ROOT = Path(__file__).resolve().parent.parent
if str(PROJECT_ROOT) not in sys.path:
    sys.path.insert(0, str(PROJECT_ROOT))

from step_editor.widgets import NoWheelComboBox
from step_editor.relation_formulas import ObjectParameterRef, parse_relation_formula
from step_editor.window_actions import WindowActionMixin
from step_editor.window_core import WindowCoreMixin
from step_editor.window_state import (
    PROPERTY_CURRENT_COLUMN,
    PROPERTY_INPUT_COLUMN,
    PROPERTY_LABEL_COLUMN,
    PROPERTY_SCOPE_COLUMN,
    PROPERTY_TABLE_HEADERS,
    PROPERTY_TARGET_COLUMN,
    RELATION_FORMULA_OBJECT_COMPLETION_LIMIT,
    WindowStateMixin,
)


class _StatusBar:
    def showMessage(self, _text: str) -> None:
        pass


class _PropertyTableProbe(QWidget, WindowStateMixin):
    def __init__(self) -> None:
        super().__init__()
        self.model = object()
        self.operation_in_progress = False
        self.scan_in_progress = False
        self.load_in_progress = False
        self.property_editor_updating = False
        self.property_table_expanded = False
        self.property_table_collapsed_rows = 5
        self.property_table_min_visible_rows = 5
        self.property_editor_selected_row = None
        self.property_command_active_key = ""
        self.property_command_buttons = {}
        self.property_editor_specs = []
        self.relation_formula_items = []
        self.relation_formula_next_id = 1
        self.selected_kind = "feature"
        self.selected_part_id = None
        self.selected_solid_id = None
        self.selected_face_id = 0
        self.selected_edge_id = None
        self.selected_pick_position = None
        self.step_path = PROJECT_ROOT / "assets" / "models" / "probe.step"
        self.current_info_values = self._plane_info()
        self.executed_property_actions: list[tuple[str, str]] = []

        layout = QVBoxLayout(self)
        self.object_edit_box = self
        self.property_table = QTableWidget(0, len(PROPERTY_TABLE_HEADERS))
        self.property_table.setHorizontalHeaderLabels(list(PROPERTY_TABLE_HEADERS))
        layout.addWidget(self.property_table)

        self.property_card_scroll = QScrollArea()
        self.property_card_container = QWidget()
        self.property_card_layout = QVBoxLayout(self.property_card_container)
        self.property_card_scroll.setWidget(self.property_card_container)
        layout.addWidget(self.property_card_scroll)

        self.property_expand_button = QPushButton()
        layout.addWidget(self.property_expand_button)

        self.property_command_summary_label = QLabel()
        self.property_command_bar = QFrame()
        self.property_command_layout = QHBoxLayout(self.property_command_bar)
        self.property_command_help_label = QLabel()
        self.current_capability_headline = QLabel()
        self.apply_property_button = QPushButton()
        self.export_parameters_button = QPushButton()
        self.relation_formula_input = QLineEdit()
        self.relation_formula_completer_model = QStringListModel(self)
        self.relation_formula_completer = QCompleter(self.relation_formula_completer_model, self)
        self.relation_formula_completer.setMaxVisibleItems(12)
        self.relation_formula_completer.activated[str].connect(self._on_relation_formula_completion_activated)
        relation_popup = self.relation_formula_completer.popup()
        if relation_popup is not None:
            relation_popup.setFocusPolicy(Qt.FocusPolicy.NoFocus)
        self.relation_formula_completer.setWidget(self.relation_formula_input)
        self.relation_formula_input.textChanged.connect(self._on_relation_formula_input_changed)
        layout.addWidget(self.relation_formula_input)
        self.add_relation_formula_button = QPushButton()
        self.remove_relation_formula_button = QPushButton()
        self.relation_formula_list = QListWidget()
        self.face_width_input = QLineEdit()
        self.face_height_input = QLineEdit()

    @staticmethod
    def _plane_info() -> dict[str, object]:
        return {
            "area": 100.0,
            "area_center": (5.0, 5.0, 0.0),
            "bbox_center": (5.0, 5.0, 0.0),
            "bbox_diagonal": 14.1421356237,
            "local_face_width": 10.0,
            "local_face_height": 10.0,
            "local_face_size_edit_ready": True,
            "local_face_size_edit_blocker": "",
            "plane_origin": (0.0, 0.0, 0.0),
            "push_pull_outward_direction": (0.0, 0.0, 1.0),
            "normal": (0.0, 0.0, 1.0),
        }

    def _selected_action_info(self) -> dict[str, object]:
        return {
            **self.current_info_values,
            "surface": "plane",
            "push_pull_status": "ready",
            "first_level_boundary_edge_count": 4,
            "first_level_boundary_vertex_count": 4,
            "first_level_adjacent_face_count": 4,
        }

    def _set_control_state(self, widget, enabled: bool, _enabled_tip: str, _disabled_tip: str) -> None:
        widget.setEnabled(enabled)

    def setTitle(self, title: str) -> None:
        self.object_edit_title = title

    def resize_face_width_local(self) -> None:
        self.executed_property_actions.append(("resize_face_width_local", self.face_width_input.text()))
        self._after_property_edit_finished(success=True)

    def resize_face_height_local(self) -> None:
        self.executed_property_actions.append(("resize_face_height_local", self.face_height_input.text()))
        self._after_property_edit_finished(success=True)

    def statusBar(self) -> _StatusBar:
        return _StatusBar()


class _RelationFormulaEventProbe(WindowCoreMixin, _PropertyTableProbe):
    pass


class _GlobalRelationCompletionModel:
    def __init__(self) -> None:
        self.faces = [object() for _index in range(100)]
        self.edges = [object() for _index in range(12)]
        self.face_logical_ids = list(range(len(self.faces)))
        self.face_region_call_count = 0

    def face_logical_id(self, face_id: int) -> int:
        return int(self.face_logical_ids[int(face_id)])

    def face_region_logical_id(self, face_id: int) -> int:
        self.face_region_call_count += 1
        return int(face_id)

    def resolve_face_selection_id(self, object_id: int) -> int | None:
        if 0 <= int(object_id) < len(self.faces):
            return int(object_id)
        return None

    def quick_face_info(self, face_id: int) -> dict[str, object]:
        return {"surface": "cylinder" if int(face_id) in {85, 87} else "plane"}


class _LargeRelationCompletionModel(_GlobalRelationCompletionModel):
    def __init__(self) -> None:
        self.faces = [object() for _index in range(10000)]
        self.edges = [object() for _index in range(1000)]
        self.face_logical_ids = list(range(len(self.faces)))
        self.face_region_call_count = 0

    def face_region_logical_id(self, face_id: int) -> int:
        self.face_region_call_count += 1
        raise AssertionError("relation formula completion should not call face_region_logical_id")


class _RelationFormulaRemapModel:
    def __init__(self, face_infos: dict[int, dict[str, object]], face_count: int = 120) -> None:
        self.faces = [object() for _index in range(face_count)]
        self.edges = []
        self.face_logical_ids = list(range(face_count))
        self.face_part_ids = [0 for _index in range(face_count)]
        self.face_solid_ids = [0 for _index in range(face_count)]
        self.face_infos = dict(face_infos)

    def face_logical_id(self, face_id: int) -> int:
        return int(self.face_logical_ids[int(face_id)])

    def face_region_logical_id(self, face_id: int) -> int:
        return self.face_logical_id(int(face_id))

    def face_ids_for_logical_id(self, logical_id: int) -> list[int]:
        return [face_id for face_id, item in enumerate(self.face_logical_ids) if int(item) == int(logical_id)]

    def resolve_face_selection_id(self, object_id: int) -> int | None:
        matches = self.face_ids_for_logical_id(int(object_id))
        if matches:
            return int(matches[0])
        if 0 <= int(object_id) < len(self.faces):
            return int(object_id)
        return None

    def quick_face_info(self, face_id: int) -> dict[str, object]:
        info = dict(self.face_infos.get(int(face_id), {}))
        if not info:
            info = {"surface": "plane", "area_center": (1000.0 + int(face_id), 0.0, 0.0), "area": 1.0}
        info.setdefault("part_id", 0)
        info.setdefault("solid_id", 0)
        info.setdefault("axis", (0.0, 0.0, 1.0))
        return info


class _ActionMessageProbe(WindowActionMixin):
    pass


class _ParameterExportActionProbe(WindowActionMixin):
    def __init__(self, output_path: Path) -> None:
        self.output_path = output_path
        self.component_path = output_path.parent / "nodes" / "000_test" / "main.py"
        self.status_bar = _StatusBarProbe()
        self.info_text = ""
        self.export_state_updates = 0

    def _parameter_export_output_path(self) -> Path:
        return self.output_path

    def _selected_parameter_export_rows(self) -> list[dict[str, str]]:
        return [
            {
                "name": "面内长度",
                "displayName": "面内长度",
                "type": "number",
                "ioRole": "input",
                "default": "151",
            },
            {
                "name": "偏移",
                "displayName": "偏移",
                "type": "number",
                "ioRole": "input",
                "default": "57.5",
            },
        ]

    def _export_parametric_component_main(self, rows: list[dict[str, str]]) -> Path:
        assert rows
        self.component_path.parent.mkdir(parents=True, exist_ok=True)
        input_rows = json.dumps(rows, ensure_ascii=False, indent=4)
        self.component_path.write_text(
            "INPUT_PARAMETERS = "
            + input_rows
            + "\nOUTPUT_PARAMETERS = [{'name': 'output_step', 'displayName': '输出STEP', 'type': 'file', 'ioRole': 'output', 'default': ''}]"
            + "\nPARAMETERS = INPUT_PARAMETERS + OUTPUT_PARAMETERS"
            + "\nNODE_INFO = {'parameters': PARAMETERS}"
            + "\ndef execute(inputs, params, context):\n    return {'output_step': 'modified.step'}\n",
            encoding="utf-8",
        )
        return self.component_path

    def _update_parameter_export_state(self) -> None:
        self.export_state_updates += 1

    def statusBar(self) -> _StatusBarProbe:
        return self.status_bar

    def set_plain_info(self, text: str) -> None:
        self.info_text = text


class _TimerProbe:
    def stop(self) -> None:
        pass


class _RenderWindowProbe:
    def Render(self) -> None:
        pass


class _StatusBarProbe:
    def __init__(self) -> None:
        self.messages: list[str] = []

    def showMessage(self, message: str) -> None:
        self.messages.append(str(message))


class _MouseSelectionProbe(WindowCoreMixin):
    def __init__(self) -> None:
        self.pointer_button_down = False
        self.left_button_press_position = None
        self.left_button_press_camera_state = None
        self.left_button_press_target = None
        self.left_button_dragged = False
        self.left_click_drag_threshold_px = 6
        self.left_click_camera_tolerance = 1e-7
        self.camera_interaction_active = False
        self.pending_hover_position = None
        self.last_hover_pick_position = None
        self.hover_timer = _TimerProbe()
        self.camera_state = (0.0, 0.0, 10.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 1.0, 10.0, 30.0)
        self.load_in_progress = False
        self.operation_in_progress = False
        self.scan_in_progress = False
        self.model = object()
        self.selected_kind = None
        self.render_window = _RenderWindowProbe()
        self.status_bar = _StatusBarProbe()
        self.pick_targets: list[dict[str, object] | None] = [
            {"kind": "face", "target_id": 1, "pick_position": (0.0, 0.0, 0.0)},
            {"kind": "face", "target_id": 1, "pick_position": (0.0, 0.0, 0.0)},
        ]
        self.selected_targets: list[dict[str, object]] = []
        self.hover_clear_count = 0
        self.camera_end_count = 0

    def _camera_state_signature(self):
        return tuple(self.camera_state)

    def _current_selection_mode(self) -> str:
        return "Face"

    def _pick_selection_target(self, _mode: str, _x: int, _y: int) -> dict[str, object] | None:
        if self.pick_targets:
            return self.pick_targets.pop(0)
        return None

    def _select_pick_target(self, target: dict[str, object]) -> None:
        self.selected_targets.append(dict(target))

    def statusBar(self) -> _StatusBarProbe:
        return self.status_bar

    def _clear_hover(self, render: bool = True) -> None:
        self.hover_clear_count += 1

    def _end_camera_interaction(self) -> None:
        self.camera_interaction_active = False
        self.camera_end_count += 1


class _TopLevelPropertyLabelProbe(QObject):
    def __init__(self) -> None:
        super().__init__()
        self.shown_labels: list[str] = []

    def eventFilter(self, watched, event):
        if (
            event.type() == QEvent.Type.Show
            and isinstance(watched, QLabel)
            and watched.isWindow()
            and watched.objectName().startswith("propertyCard")
        ):
            self.shown_labels.append(f"{type(watched).__name__}:{watched.objectName()}:{watched.text()}")
        return False


def _assert(condition: bool, message: str) -> None:
    if not condition:
        raise AssertionError(message)


def _row_by_label(probe: _PropertyTableProbe, label: str) -> int:
    for row in range(probe.property_table.rowCount()):
        item = probe.property_table.item(row, PROPERTY_LABEL_COLUMN)
        if item is not None and item.text() == label:
            return row
    labels = [
        probe.property_table.item(row, PROPERTY_LABEL_COLUMN).text()
        for row in range(probe.property_table.rowCount())
        if probe.property_table.item(row, PROPERTY_LABEL_COLUMN) is not None
    ]
    raise AssertionError(f"{label!r} row was not found; labels={labels}")


def _assert_property_table_editor(probe: _PropertyTableProbe) -> None:
    _assert(
        not WindowCoreMixin._should_suppress_transient_tooltip(probe, probe.property_table),
        "property table tooltip events should not be suppressed",
    )
    _assert(
        not WindowCoreMixin._should_suppress_transient_tooltip(probe, probe.property_table.viewport()),
        "property table viewport tooltip events should not be suppressed",
    )
    headers = [
        probe.property_table.horizontalHeaderItem(column).text()
        for column in range(probe.property_table.columnCount())
    ]
    _assert(headers == list(PROPERTY_TABLE_HEADERS), f"unexpected table headers: {headers}")
    _assert(probe.property_table.rowCount() == len(probe.property_editor_specs), "table row count should match specs")
    header_height = int(probe.property_table.horizontalHeader().height())
    frame = int(probe.property_table.frameWidth()) * 2
    default_row_height = max(int(probe.property_table.verticalHeader().defaultSectionSize()), 22)
    expected_five_row_height = header_height + frame + default_row_height * 5 + 8
    _assert(
        probe.property_table.minimumHeight() >= expected_five_row_height,
        "feature parameter table should reserve enough height for five default rows",
    )
    _assert(not getattr(probe, "property_card_rows", {}), "property card rows should not be built in table mode")
    _assert(not probe.property_card_scroll.isVisible(), "property card scroll area should stay hidden")
    _assert(probe.property_card_scroll.maximumHeight() == 0, "property card scroll area should not reserve height")
    _assert(not probe.property_command_buttons, "legacy command buttons should not be shown in the parameter table")
    _assert(not probe.property_command_bar.isVisible(), "legacy command bar should be hidden")

    table_labels = [
        probe.property_table.item(row, PROPERTY_LABEL_COLUMN).text()
        for row in range(probe.property_table.rowCount())
        if probe.property_table.item(row, PROPERTY_LABEL_COLUMN) is not None
    ]
    actionable_labels = [str(spec.get("label", "")) for _row, spec in probe._actionable_property_rows()]
    for label in ("面内长度", "面内宽度", "偏移"):
        _assert(label in actionable_labels, f"feature parameter table did not expose {label}")
    _assert("中心" not in actionable_labels, "center should be temporarily hidden from editable parameters")
    _assert("中心" not in table_labels, "center should not appear in the feature parameter table")
    for legacy_label in ("面积", "U向尺寸", "V向尺寸", "偏移变换"):
        _assert(legacy_label not in actionable_labels, f"{legacy_label} should not be exposed as an editable parameter")
        _assert(legacy_label not in table_labels, f"{legacy_label} should not appear in the feature parameter table")
    for diagnostic_label in ("建模形式", "推荐操作", "一级关系", "关联探测"):
        _assert(diagnostic_label not in table_labels, f"{diagnostic_label} should stay out of the feature parameter table")

    target_row = _row_by_label(probe, "面内长度")
    target_widget = probe.property_table.cellWidget(target_row, PROPERTY_TARGET_COLUMN)
    scope_widget = probe.property_table.cellWidget(target_row, PROPERTY_SCOPE_COLUMN)
    input_checkbox = probe._property_input_checkbox(target_row)
    _assert(isinstance(target_widget, QLineEdit), "editable table row should have a target editor")
    _assert(isinstance(scope_widget, NoWheelComboBox), "editable table row should have a modeling-intent combo")
    _assert(isinstance(input_checkbox, QCheckBox), "editable table row should have an input-parameter checkbox")
    _assert(not input_checkbox.isChecked(), "input-parameter checkbox should be unchecked by default")
    _assert(
        probe.property_table.cellWidget(target_row, PROPERTY_INPUT_COLUMN) is not None,
        "input-parameter checkbox should be hosted in the input column",
    )
    _assert(not probe.export_parameters_button.isEnabled(), "parameter export button should start disabled")
    _assert(
        not probe.property_table.findChildren(QPushButton),
        "feature parameter table should not contain per-row apply buttons",
    )

    input_checkbox.setChecked(True)
    QApplication.processEvents()
    selected_rows = probe._selected_parameter_export_rows()
    _assert(probe.export_parameters_button.isEnabled(), "parameter export button should enable after a row is checked")
    _assert(
        selected_rows == [
            {
                "name": "面内长度",
                "displayName": "面内长度",
                "type": "number",
                "ioRole": "input",
                "default": "10",
            }
        ],
        f"unexpected parameter export payload: {selected_rows}",
    )
    component_edits = probe._selected_parameter_component_edits(selected_rows)
    _assert(len(component_edits) == 1, f"selected parameter should map to one component edit: {component_edits}")
    _assert(
        component_edits[0]["operation"] == "resize_face_size_local",
        f"face width export should map to backend resize operation: {component_edits[0]}",
    )
    _assert(
        component_edits[0]["args"] == [0, {"param": "面内长度"}, "width"],
        f"face width export should embed parameter placeholder args: {component_edits[0]}",
    )

    target_widget.setText("12")
    probe._update_property_apply_state()
    changed = probe._changed_property_rows()
    _assert(any(row == target_row for row, _spec, _text in changed), "table target edit was not detected")
    _assert(probe.apply_property_button.isEnabled(), "single parametric modeling button should enable for one changed row")

    width_row = _row_by_label(probe, "面内宽度")
    width_widget = probe.property_table.cellWidget(width_row, PROPERTY_TARGET_COLUMN)
    _assert(isinstance(width_widget, QLineEdit), "second editable table row should have a target editor")
    width_widget.setText("8")
    probe._update_property_apply_state()
    changed = probe._changed_property_rows()
    _assert(len(changed) >= 2, f"two target edits should be detected: {changed}")
    _assert(probe.apply_property_button.isEnabled(), "parametric modeling button should stay enabled for multiple changed rows")
    probe.apply_current_property_edit()
    for _index in range(6):
        QApplication.processEvents()
        if not getattr(probe, "property_batch_active", False):
            break
    _assert(
        probe.executed_property_actions == [
            ("resize_face_width_local", "12"),
            ("resize_face_height_local", "8"),
        ],
        f"batch parametric modeling should execute changed rows in table order: {probe.executed_property_actions}",
    )
    _assert(not getattr(probe, "property_batch_active", False), "property batch state should clear after completion")

    probe.toggle_property_table_expanded()
    _assert(probe.property_table_expanded, "property table expand toggle failed")
    _assert("收起" in probe.property_expand_button.text(), "expanded table button should offer to collapse")
    preserved_editor = probe.property_table.cellWidget(target_row, PROPERTY_TARGET_COLUMN)
    _assert(isinstance(preserved_editor, QLineEdit), "target editor disappeared after table expand")
    _assert(preserved_editor.text().strip() == "12", "target value was not preserved after table expand")


def _assert_diagnostics_stay_out_of_parameter_table(probe: _PropertyTableProbe) -> None:
    long_context = "已按“相邻特征”沿共享边拓扑探测当前特征及 3 个局部关联特征；关联尺寸可在同一参数表中直接修改。"
    probe.current_info_values = {
        **probe._plane_info(),
        "feature_context_note": long_context,
        "feature_detection_level": "相邻特征",
        "associated_feature_count": 3,
    }
    probe._refresh_property_editor()
    QApplication.processEvents()
    table_labels = [
        probe.property_table.item(row, PROPERTY_LABEL_COLUMN).text()
        for row in range(probe.property_table.rowCount())
        if probe.property_table.item(row, PROPERTY_LABEL_COLUMN) is not None
    ]
    for diagnostic_label in ("建模形式", "推荐操作", "一级关系", "关联探测"):
        _assert(diagnostic_label not in table_labels, f"{diagnostic_label} should not be shown as a feature parameter")


def _assert_relation_formula_editor() -> None:
    probe = _PropertyTableProbe()
    probe._refresh_property_editor()
    completions = set(probe.relation_formula_completer_model.stringList())
    _assert("Face0.面内长度" in completions, f"relation formula completion missing face length: {completions}")
    _assert("Face0.面内宽度" in completions, f"relation formula completion missing face width: {completions}")
    probe.relation_formula_input.setText("F")
    probe.relation_formula_input.setCursorPosition(1)
    probe._update_relation_formula_completions()
    f_completions = set(probe.relation_formula_completer_model.stringList())
    _assert(
        "Face" in f_completions or "Face0" in f_completions,
        f"relation formula should suggest face object tokens after 'F': {f_completions}",
    )
    _assert(probe.relation_formula_completer.completionCount() > 0, "relation formula completer should have matches after 'F'")
    _assert(probe._accept_relation_formula_completion(), "Tab should accept relation formula completion after 'F'")
    _assert(
        probe.relation_formula_input.text() in {"Face", "Face0"},
        f"Tab should replace 'F' with a face completion: {probe.relation_formula_input.text()}",
    )
    if probe.relation_formula_input.text() == "Face":
        probe._update_relation_formula_completions()
        face_object_completions = set(probe.relation_formula_completer_model.stringList())
        _assert(
            "Face0" in face_object_completions,
            f"relation formula should suggest concrete Face IDs after completing Face: {face_object_completions}",
        )
        _assert(probe._accept_relation_formula_completion(), "second Tab should accept a concrete Face ID completion")
        _assert(
            probe.relation_formula_input.text() == "Face0",
            f"second Tab should complete Face to Face0: {probe.relation_formula_input.text()}",
        )
    probe._update_relation_formula_completions()
    exact_object_completions = set(probe.relation_formula_completer_model.stringList())
    _assert(
        any(str(item).startswith("Face0.") for item in exact_object_completions),
        f"concrete object completion should suggest editable parameters: {exact_object_completions}",
    )
    event_probe = _RelationFormulaEventProbe()
    event_probe.show()
    event_probe._refresh_property_editor()
    event_probe.relation_formula_input.setFocus(Qt.FocusReason.OtherFocusReason)
    QApplication.processEvents()
    event_probe.relation_formula_input.setText("F")
    event_probe.relation_formula_input.setCursorPosition(1)
    tab_event = QKeyEvent(QEvent.Type.ShortcutOverride, Qt.Key.Key_Tab, Qt.KeyboardModifier.NoModifier)
    _assert(
        event_probe.eventFilter(event_probe.relation_formula_input, tab_event),
        "relation formula input should consume Tab before Qt moves focus",
    )
    _assert(
        event_probe.relation_formula_input.text() in {"Face", "Face0"},
        f"ShortcutOverride Tab should accept the face completion: {event_probe.relation_formula_input.text()}",
    )
    QApplication.processEvents()
    _assert(event_probe.relation_formula_input.hasFocus(), "relation formula input should keep focus after Tab completion")
    popup = event_probe.relation_formula_completer.popup()
    if popup is not None:
        popup.installEventFilter(event_probe)
        before_backspace = event_probe.relation_formula_input.text()
        popup_backspace = QKeyEvent(QEvent.Type.KeyPress, Qt.Key.Key_Backspace, Qt.KeyboardModifier.NoModifier)
        _assert(
            event_probe.eventFilter(popup, popup_backspace),
            "relation formula completer popup should forward Backspace to the input",
        )
        _assert(
            event_probe.relation_formula_input.text() == before_backspace[:-1],
            f"Backspace should edit the input even if popup receives it: {event_probe.relation_formula_input.text()}",
        )
        _assert(event_probe.relation_formula_input.hasFocus(), "relation formula input should keep focus after popup Backspace")
    global_probe = _PropertyTableProbe()
    global_probe.model = _GlobalRelationCompletionModel()
    global_probe.selected_kind = "face"
    global_probe.selected_face_id = 0
    global_probe.show()
    global_probe._refresh_property_editor()
    global_probe.relation_formula_input.setFocus(Qt.FocusReason.OtherFocusReason)
    QApplication.processEvents()
    global_probe.model.face_region_call_count = 0
    global_probe.relation_formula_input.setText("Face")
    global_probe.relation_formula_input.setCursorPosition(len("Face"))
    global_probe._update_relation_formula_completions()
    global_probe._show_relation_formula_completion_popup()
    QApplication.processEvents()
    global_face_completion_list = list(global_probe.relation_formula_completer_model.stringList())
    global_face_completions = set(global_face_completion_list)
    _assert("Face85" in global_face_completions, f"global Face completion should include Face85: {global_face_completions}")
    _assert("Face85." not in global_face_completions, f"object completion should not show trailing dot: {global_face_completions}")
    _assert(
        global_face_completion_list.index("Face2") < global_face_completion_list.index("Face10") < global_face_completion_list.index("Face85"),
        f"Face completions should be sorted by numeric ID: {global_face_completion_list[:20]}",
    )
    global_probe.relation_formula_input.setText("Face8")
    global_probe.relation_formula_input.setCursorPosition(len("Face8"))
    global_probe._update_relation_formula_completions()
    face8_completion_list = list(global_probe.relation_formula_completer_model.stringList())
    _assert("Face87" in face8_completion_list, f"Face8 should still suggest longer Face IDs: {face8_completion_list[:20]}")
    _assert(
        face8_completion_list[0] != "Face8",
        f"Face8 completion should prefer longer IDs instead of no-op self completion: {face8_completion_list[:20]}",
    )
    _assert(
        face8_completion_list.index("Face80") < face8_completion_list.index("Face87"),
        f"Face8 completions should keep numeric order: {face8_completion_list[:20]}",
    )
    face8_tab_probe = _PropertyTableProbe()
    face8_tab_probe.model = _GlobalRelationCompletionModel()
    face8_tab_probe.selected_kind = "face"
    face8_tab_probe.selected_face_id = 0
    face8_tab_probe._refresh_property_editor()
    face8_tab_probe.relation_formula_input.setText("Face8")
    face8_tab_probe.relation_formula_input.setCursorPosition(len("Face8"))
    _assert(face8_tab_probe._accept_relation_formula_completion(), "Tab should accept a longer Face8 completion")
    _assert(
        face8_tab_probe.relation_formula_input.text().startswith("Face8")
        and face8_tab_probe.relation_formula_input.text() != "Face8",
        f"Tab after Face8 should complete to a longer ID, not stay unchanged: {face8_tab_probe.relation_formula_input.text()}",
    )
    face_tab_probe = _RelationFormulaEventProbe()
    face_tab_probe.model = _GlobalRelationCompletionModel()
    face_tab_probe.selected_kind = "face"
    face_tab_probe.selected_face_id = 0
    face_tab_probe.show()
    face_tab_probe._refresh_property_editor()
    face_tab_probe.relation_formula_input.setFocus(Qt.FocusReason.OtherFocusReason)
    QApplication.processEvents()
    face_tab_probe.relation_formula_input.setText("F")
    face_tab_probe.relation_formula_input.setCursorPosition(len("F"))
    face_tab_event = QKeyEvent(QEvent.Type.ShortcutOverride, Qt.Key.Key_Tab, Qt.KeyboardModifier.NoModifier)
    _assert(face_tab_probe.eventFilter(face_tab_probe.relation_formula_input, face_tab_event), "F + Tab should be consumed")
    for _index in range(4):
        QApplication.processEvents()
    _assert(face_tab_probe.relation_formula_input.text() == "Face", f"F + Tab should complete to Face: {face_tab_probe.relation_formula_input.text()}")
    _assert("Face87" in set(face_tab_probe.relation_formula_completer_model.stringList()), "Face layer should suggest Face87 after F + Tab")
    _assert(face_tab_probe.relation_formula_completer.popup().isVisible(), "Face layer popup should open after F + Tab")
    _assert(
        face_tab_probe.relation_formula_completer.popup().minimumWidth()
        >= max(face_tab_probe.relation_formula_input.width(), 320),
        "Face completion popup should be wide enough to show text",
    )
    face_manual_probe = _RelationFormulaEventProbe()
    face_manual_probe.model = _GlobalRelationCompletionModel()
    face_manual_probe.selected_kind = "face"
    face_manual_probe.selected_face_id = 0
    face_manual_probe.show()
    face_manual_probe._refresh_property_editor()
    face_manual_probe.relation_formula_input.setFocus(Qt.FocusReason.OtherFocusReason)
    QApplication.processEvents()
    face_manual_probe.relation_formula_input.setText("Face")
    face_manual_probe.relation_formula_input.setCursorPosition(len("Face"))
    for _index in range(4):
        QApplication.processEvents()
    _assert("Face87" in set(face_manual_probe.relation_formula_completer_model.stringList()), "manual Face input should suggest Face87")
    _assert(face_manual_probe.relation_formula_completer.popup().isVisible(), "manual Face input should open the next completion layer")
    _assert(
        face_manual_probe.relation_formula_completer.popup().minimumWidth()
        >= max(face_manual_probe.relation_formula_input.width(), 320),
        "manual Face popup should not collapse to cursor width",
    )
    global_probe.relation_formula_input.setText("Face87")
    global_probe.relation_formula_input.setCursorPosition(len("Face87"))
    global_probe._update_relation_formula_completions()
    face87_completion_list = list(global_probe.relation_formula_completer_model.stringList())
    face87_ref = next((item for item in face87_completion_list if str(item).startswith("Face87.")), "")
    _assert(face87_ref, f"exact Face ID should suggest editable parameters: {face87_completion_list}")
    face87_radius_ref = next((item for item in face87_completion_list if str(item).endswith("半径")), "")
    _assert(face87_radius_ref, f"exact Face ID should suggest radius: {face87_completion_list}")
    radius_probe = _PropertyTableProbe()
    radius_probe.model = _GlobalRelationCompletionModel()
    radius_probe.selected_kind = "face"
    radius_probe.selected_face_id = 0
    radius_probe.show()
    radius_probe._refresh_property_editor()
    radius_probe.relation_formula_input.setFocus(Qt.FocusReason.OtherFocusReason)
    QApplication.processEvents()
    radius_probe.relation_formula_input.setText("Face87")
    radius_probe.relation_formula_input.setCursorPosition(len("Face87"))
    radius_probe._update_relation_formula_completions()
    radius_probe._show_relation_formula_completion_popup()
    QApplication.processEvents()
    radius_completion_list = list(radius_probe.relation_formula_completer_model.stringList())
    radius_row = radius_completion_list.index(face87_radius_ref)
    radius_model = radius_probe.relation_formula_completer.model()
    radius_popup = radius_probe.relation_formula_completer.popup()
    radius_probe.relation_formula_completer.setCurrentRow(radius_row)
    radius_popup.setCurrentIndex(radius_model.index(radius_row, 0))
    _assert(radius_probe._accept_relation_formula_completion(), "Tab should accept the popup-selected radius completion")
    _assert(
        radius_probe.relation_formula_input.text() == face87_radius_ref,
        f"Tab should keep the popup-selected completion, not reset to default: {radius_probe.relation_formula_input.text()}",
    )
    global_probe.relation_formula_input.setText(face87_ref)
    global_probe.relation_formula_input.setCursorPosition(len(face87_ref))
    global_probe._update_relation_formula_completions()
    _assert(" = " in set(global_probe.relation_formula_completer_model.stringList()), "complete Face parameter should suggest '='")
    global_probe._on_relation_formula_completion_activated(" = ")
    _assert(
        global_probe.relation_formula_input.text() == f"{face87_ref} = ",
        f"mouse activation should insert '=' without replacing the whole formula: {global_probe.relation_formula_input.text()}",
    )
    global_probe.relation_formula_input.setText(face87_ref)
    global_probe.relation_formula_input.setCursorPosition(len(face87_ref))
    global_probe._update_relation_formula_completions()
    global_probe.relation_formula_input.setText(f"{face87_ref} = F")
    global_probe.relation_formula_input.setCursorPosition(len(f"{face87_ref} = F"))
    global_probe._update_relation_formula_completions()
    rhs_f_completion_list = list(global_probe.relation_formula_completer_model.stringList())
    _assert(
        "Face85" in rhs_f_completion_list and "Face87" in rhs_f_completion_list,
        f"right-hand expression should suggest global Face IDs after F: {rhs_f_completion_list[:20]}",
    )
    global_probe.relation_formula_input.setText(f"{face87_ref} = Face8")
    global_probe.relation_formula_input.setCursorPosition(len(f"{face87_ref} = Face8"))
    global_probe._update_relation_formula_completions()
    rhs_face8_completion_list = list(global_probe.relation_formula_completer_model.stringList())
    _assert("Face87" in rhs_face8_completion_list, f"right-hand Face8 should suggest Face87: {rhs_face8_completion_list[:20]}")
    global_probe.relation_formula_input.setText(f"{face87_ref} = Face87")
    global_probe.relation_formula_input.setCursorPosition(len(f"{face87_ref} = Face87"))
    global_probe._update_relation_formula_completions()
    rhs_face87_completion_list = list(global_probe.relation_formula_completer_model.stringList())
    _assert(
        any(str(item).startswith("Face87.") for item in rhs_face87_completion_list),
        f"right-hand exact Face ID should suggest parameters: {rhs_face87_completion_list}",
    )
    global_probe.relation_formula_input.setText("Edge")
    global_probe.relation_formula_input.setCursorPosition(len("Edge"))
    global_probe._update_relation_formula_completions()
    global_edge_completion_list = list(global_probe.relation_formula_completer_model.stringList())
    global_edge_completions = set(global_edge_completion_list)
    _assert("Edge0" in global_edge_completions, f"Edge completion should be available even in Face selection mode: {global_edge_completions}")
    _assert(
        global_edge_completion_list.index("Edge2") < global_edge_completion_list.index("Edge10"),
        f"Edge completions should be sorted by numeric ID: {global_edge_completion_list}",
    )
    _assert(
        global_probe.model.face_region_call_count == 0,
        f"relation formula typing should not call heavy face_region_logical_id: {global_probe.model.face_region_call_count}",
    )
    large_probe = _PropertyTableProbe()
    large_probe.model = _LargeRelationCompletionModel()
    large_probe.selected_kind = "face"
    large_probe.selected_face_id = 0
    large_probe._refresh_property_editor()
    large_probe.model.face_region_call_count = 0
    large_probe.relation_formula_input.setText("F")
    large_probe.relation_formula_input.setCursorPosition(len("F"))
    large_probe._update_relation_formula_completions()
    large_completions = list(large_probe.relation_formula_completer_model.stringList())
    _assert("Face87" in large_completions, f"large model F completion should still include common Face IDs: {large_completions[:20]}")
    _assert(
        len(large_completions) <= RELATION_FORMULA_OBJECT_COMPLETION_LIMIT + 2,
        f"large model broad completion should be capped: {len(large_completions)}",
    )
    _assert(
        large_probe.model.face_region_call_count == 0,
        f"large model completion should not call heavy face_region_logical_id: {large_probe.model.face_region_call_count}",
    )
    probe.relation_formula_input.setText("Face0.")
    probe.relation_formula_input.setCursorPosition(len("Face0."))
    probe._update_relation_formula_completions()
    face_completions = set(probe.relation_formula_completer_model.stringList())
    _assert("Face0.面内长度" in face_completions, f"relation formula should suggest parameters after Face0.: {face_completions}")
    probe.relation_formula_input.setText("Face0.面内宽度")
    probe.relation_formula_input.setCursorPosition(len("Face0.面内宽度"))
    probe._update_relation_formula_completions()
    _assert(" = " in set(probe.relation_formula_completer_model.stringList()), "relation formula should suggest '=' after a target parameter")
    probe.relation_formula_input.setText("Face0.面内宽度 = Face0.面内长度 * 1.2")
    probe.add_relation_formula()
    _assert(len(probe.relation_formula_items) == 1, f"formula was not stored: {probe.relation_formula_items}")
    _assert(probe.relation_formula_list.count() == 1, "formula list should display the stored formula")
    for _index in range(6):
        QApplication.processEvents()
        if not getattr(probe, "relation_formula_replay_active", False):
            break
    _assert(
        probe.executed_property_actions == [("resize_face_height_local", "12")],
        f"formula should immediately fill target value and execute the existing row action: {probe.executed_property_actions}",
    )
    width_row = _row_by_label(probe, "面内宽度")
    width_widget = probe.property_table.cellWidget(width_row, PROPERTY_TARGET_COLUMN)
    _assert(isinstance(width_widget, QLineEdit), "formula target row should still have a target editor")
    _assert(width_widget.text().strip() == "12", "formula result should be written back to the target value cell")
    _assert(str(probe.relation_formula_items[0].get("status")) == "applied", "formula should be marked as applied")
    for _index in range(4):
        QApplication.processEvents()
    _assert(probe.relation_formula_input.isEnabled(), "relation formula input should stay enabled after one formula is applied")
    probe.relation_formula_input.setText("F")
    _assert(probe.add_relation_formula_button.isEnabled(), "existing formulas should not disable adding another formula")


def _assert_relation_radius_formula_proxy() -> None:
    probe = _PropertyTableProbe()
    probe.model = _GlobalRelationCompletionModel()
    probe.selected_kind = "face"
    probe.selected_face_id = 87
    probe.property_table.setRowCount(1)
    probe.property_editor_specs = [
        {
            "key": "diameter",
            "label": "直径",
            "current_raw": 1.0,
            "current_text": "1",
            "target_text": "1",
            "editable": True,
            "enabled": True,
            "action": "resize_hole",
            "value_type": "number",
            "source_face_id": 87,
        }
    ]
    probe.property_table.setItem(0, PROPERTY_LABEL_COLUMN, QTableWidgetItem("直径"))
    target = QLineEdit("1")
    probe.property_table.setCellWidget(0, PROPERTY_TARGET_COLUMN, target)

    ref = ObjectParameterRef("Face", 87, "半径")
    visible = probe._relation_visible_spec_for_ref(ref)
    _assert(visible is not None, "Face radius formula should fall back to an executable diameter row")
    _assert(
        abs(float(probe._relation_value_for_ref(ref)) - 0.5) <= 1e-9,
        f"radius formula should read half of the diameter: {probe._relation_value_for_ref(ref)}",
    )
    row = probe._set_relation_target_value(ref, 0.6)
    _assert(row == 0, f"radius proxy should write to the diameter row: {row}")
    _assert(target.text() == "1.2", f"radius proxy should convert target radius to diameter: {target.text()}")


def _assert_relation_formula_input_remains_editable_while_replaying() -> None:
    probe = _PropertyTableProbe()
    probe.model = _GlobalRelationCompletionModel()
    probe.selected_kind = "face"
    probe.selected_face_id = 87
    probe._refresh_property_editor()
    probe.operation_in_progress = True
    probe.relation_formula_replay_active = True
    probe.relation_formula_replay_queue = []
    probe.relation_formula_replay_total = 1
    probe.relation_formula_input.setEnabled(False)
    probe._update_relation_formula_buttons()
    _assert(probe.relation_formula_input.isEnabled(), "relation formula input should stay editable while formulas replay")

    probe.relation_formula_input.setText("Face87.半径 = Face85.半径")
    probe.add_relation_formula()
    _assert(len(probe.relation_formula_items) == 1, f"formula should be stored while replaying: {probe.relation_formula_items}")
    _assert(len(probe.relation_formula_replay_queue) == 1, f"formula should be queued while replaying: {probe.relation_formula_replay_queue}")
    _assert(probe.relation_formula_input.text() == "", "queued formula should clear the input for the next formula")
    _assert(probe.relation_formula_input.isEnabled(), "relation formula input should remain enabled after queuing")
    _assert(probe.relation_formula_replay_active, "adding a queued formula should not stop the current replay")


def _assert_relation_formula_input_clickable_after_existing_formula() -> None:
    probe = _RelationFormulaEventProbe()
    probe.relation_formula_input.installEventFilter(probe)
    probe.show()
    probe._refresh_property_editor()
    probe.relation_formula_input.setText("Face0.面内宽度 = Face0.面内长度 * 1.2")
    probe.add_relation_formula()
    for _index in range(12):
        QApplication.processEvents()
        if not getattr(probe, "relation_formula_replay_active", False):
            break
    _assert(len(probe.relation_formula_items) == 1, f"formula should exist before click test: {probe.relation_formula_items}")
    _assert(str(probe.relation_formula_items[0].get("status")) == "applied", "formula should be applied before click test")
    probe.activateWindow()
    probe.raise_()
    QApplication.processEvents()
    QTest.mouseClick(probe.relation_formula_input, Qt.MouseButton.LeftButton)
    QApplication.processEvents()
    _assert(probe.relation_formula_input.isEnabled(), "relation formula input should stay enabled with an existing formula")
    _assert(probe.relation_formula_input.hasFocus(), "clicking the relation formula input should focus it with an existing formula")
    probe.relation_formula_input.setText("F")
    _assert(probe.add_relation_formula_button.isEnabled(), "clickable input should allow adding another formula")


def _assert_relation_formula_input_is_selection_independent() -> None:
    probe = _RelationFormulaEventProbe()
    probe.relation_formula_input.installEventFilter(probe)
    probe.model = _GlobalRelationCompletionModel()
    probe.selected_kind = None
    probe.selected_face_id = None
    probe.selected_edge_id = None
    probe.relation_formula_items = []
    probe.relation_formula_input.setEnabled(False)
    probe._refresh_relation_formula_list()
    _assert(probe.relation_formula_input.isEnabled(), "relation formula input should be editable without a selected face")
    _assert(not probe.relation_formula_input.isReadOnly(), "relation formula input should not become read-only without a selected face")
    _assert(not probe.add_relation_formula_button.isEnabled(), "empty relation formula should not enable the add button")

    probe.show()
    probe.activateWindow()
    probe.raise_()
    QApplication.processEvents()
    QTest.mouseClick(probe.relation_formula_input, Qt.MouseButton.LeftButton)
    QApplication.processEvents()

    probe.relation_formula_input.setText("Face8")
    probe.relation_formula_input.setCursorPosition(len("Face8"))
    probe._update_relation_formula_completions()
    object_completions = list(probe.relation_formula_completer_model.stringList())
    _assert("Face85" in object_completions and "Face87" in object_completions, f"global face completions should not require selection: {object_completions[:20]}")

    probe.relation_formula_input.setText("Face85")
    probe.relation_formula_input.setCursorPosition(len("Face85"))
    probe._update_relation_formula_completions()
    parameter_completions = list(probe.relation_formula_completer_model.stringList())
    _assert(any(str(item).startswith("Face85.") for item in parameter_completions), f"Face parameter completions should not require selection: {parameter_completions}")


def _assert_relation_formula_input_recovers_after_loading() -> None:
    probe = _RelationFormulaEventProbe()
    probe.model = _GlobalRelationCompletionModel()
    probe.mode_combo = NoWheelComboBox()
    probe.mode_combo.addItem("Face", "Face")
    probe.load_thread = None
    probe.load_refine_thread = None
    probe.pending_load_path = None
    probe.load_in_progress = True
    probe._update_relation_formula_buttons()
    _assert(not probe.relation_formula_input.isEnabled(), "relation formula input should be disabled while loading")

    probe._end_load_task()
    _assert(probe.relation_formula_input.isEnabled(), "relation formula input should recover after loading without selecting a face")


def _assert_relation_formula_ids_follow_model_remap() -> None:
    old_model = _RelationFormulaRemapModel(
        {
            85: {"surface": "cylinder", "area_center": (0.5, 1.0, 9.5), "bbox_center": (0.5, 1.0, 9.5), "radius": 0.25, "area": 8.0},
            87: {"surface": "cylinder", "area_center": (2.0, 1.0, 9.5), "bbox_center": (2.0, 1.0, 9.5), "radius": 0.25, "area": 8.0},
        }
    )
    new_model = _RelationFormulaRemapModel(
        {
            90: {"surface": "cylinder", "area_center": (0.5, 1.0, 9.5), "bbox_center": (0.5, 1.0, 9.5), "radius": 0.25, "area": 8.0},
            92: {"surface": "cylinder", "area_center": (2.0, 1.0, 9.5), "bbox_center": (2.0, 1.0, 9.5), "radius": 0.15, "area": 5.0},
        }
    )
    probe = _PropertyTableProbe()
    formula_text = "Face87.直径 = Face85.半径"
    probe.model = old_model
    formula = parse_relation_formula(formula_text)
    probe.relation_formula_items = [
        {
            "id": 1,
            "text": formula_text,
            "enabled": True,
            "status": "applied",
            "message": "已修改模型。",
            "signatures": probe._relation_signatures_for_formula(formula),
        }
    ]
    probe.model = new_model
    note = probe._refresh_relation_formulas_after_model_edit()
    _assert(
        probe.relation_formula_items[0]["text"] == "Face92.直径 = Face90.半径",
        f"relation formula should follow remapped visible Face IDs: {probe.relation_formula_items}",
    )
    _assert("Face ID" in note, f"relation remap note should mention updated Face IDs: {note}")

    old_model = _RelationFormulaRemapModel(
        {
            85: {"surface": "cylinder", "area_center": (0.5, 1.0, 9.5), "bbox_center": (0.5, 1.0, 9.5), "radius": 0.25, "area": 8.0},
            87: {"surface": "cylinder", "area_center": (0.5, 1.0, 0.5), "bbox_center": (0.5, 1.0, 0.5), "radius": 0.25, "area": 8.0},
        }
    )
    new_model = _RelationFormulaRemapModel(
        {
            85: {"surface": "cylinder", "area_center": (0.5, 1.0, 9.5), "bbox_center": (0.5, 1.0, 9.5), "radius": 0.125, "area": 4.0},
            11: {"surface": "cylinder", "area_center": (0.5, 1.0, 0.5), "bbox_center": (0.5, 1.0, 0.5), "radius": 0.25, "area": 8.0},
        }
    )
    probe = _PropertyTableProbe()
    formula_text = "Face85.直径 = Face87.半径"
    probe.model = old_model
    formula = parse_relation_formula(formula_text)
    probe.relation_formula_items = [
        {
            "id": 1,
            "text": formula_text,
            "enabled": True,
            "status": "applied",
            "message": "已修改模型。",
            "signatures": probe._relation_signatures_for_formula(formula),
        }
    ]
    probe.model = new_model
    probe._refresh_relation_formulas_after_model_edit()
    _assert(
        probe.relation_formula_items[0]["text"] == "Face85.直径 = Face11.半径",
        f"relation formula should remap a changed reference ID even when the target ID is preserved: {probe.relation_formula_items}",
    )

    old_model = _RelationFormulaRemapModel(
        {
            85: {"surface": "cylinder", "area_center": (0.5, 1.0, 9.5), "bbox_center": (0.5, 1.0, 9.5), "radius": 0.25, "area": 8.0},
            87: {"surface": "cylinder", "area_center": (0.5, 1.0, 0.5), "bbox_center": (0.5, 1.0, 0.5), "radius": 0.25, "area": 8.0},
        }
    )
    new_model = _RelationFormulaRemapModel(
        {
            85: {"surface": "cylinder", "area_center": (0.5, 1.0, 0.5), "bbox_center": (0.5, 1.0, 0.5), "radius": 0.5, "area": 16.0},
            89: {"surface": "cylinder", "area_center": (0.5, 1.0, 9.5), "bbox_center": (0.5, 1.0, 9.5), "radius": 0.125, "area": 4.0},
            91: {"surface": "cylinder", "area_center": (0.5, 1.0, 0.5), "bbox_center": (0.5, 1.0, 0.5), "radius": 0.25, "area": 8.0},
        }
    )
    new_model.face_logical_ids[89] = 85
    probe = _PropertyTableProbe()
    formula_text = "Face85.直径 = Face87.半径"
    probe.model = old_model
    formula = parse_relation_formula(formula_text)
    probe.relation_formula_items = [
        {
            "id": 1,
            "text": formula_text,
            "enabled": True,
            "status": "applied",
            "message": "已修改模型。",
            "signatures": probe._relation_signatures_for_formula(formula),
        }
    ]
    probe.model = new_model
    probe._refresh_relation_formulas_after_model_edit()
    _assert(
        probe.relation_formula_items[0]["text"] == "Face85.直径 = Face91.半径",
        f"relation remap should prefer the old reference radius over a same-center changed target: {probe.relation_formula_items}",
    )

    old_model = _RelationFormulaRemapModel(
        {
            9: {"surface": "cylinder", "area_center": (0.5, 1.0, 9.5), "bbox_center": (0.5, 1.0, 9.5), "radius": 0.25, "area": 8.0},
            87: {"surface": "cylinder", "area_center": (0.5, 1.0, 0.5), "bbox_center": (0.5, 1.0, 0.5), "radius": 0.15, "area": 4.8},
        }
    )
    new_model = _RelationFormulaRemapModel(
        {
            14: {"surface": "cylinder", "area_center": (0.5, 1.0, 9.5), "bbox_center": (0.5, 1.0, 9.5), "radius": 0.4, "area": 12.8},
            87: {"surface": "cylinder", "area_center": (0.5, 1.0, 0.5), "bbox_center": (0.5, 1.0, 0.5), "radius": 0.15, "area": 4.8},
        }
    )
    new_model.face_logical_ids[14] = 9
    probe = _PropertyTableProbe()
    formula_text = "Face87.直径 = Face9.半径"
    probe.model = old_model
    formula = parse_relation_formula(formula_text)
    probe.relation_formula_items = [
        {
            "id": 1,
            "text": formula_text,
            "enabled": True,
            "status": "applied",
            "message": "已修改模型。",
            "signatures": probe._relation_signatures_for_formula(formula),
        }
    ]
    probe.model = new_model
    probe._refresh_relation_formulas_after_model_edit(
        context={"target_kind": "face", "target_id": 9, "target_logical_id": 9}
    )
    _assert(
        probe.relation_formula_items[0]["text"] == "Face87.直径 = Face9.半径",
        f"edited right-hand dependency should keep its logical Face ID instead of becoming invalid: {probe.relation_formula_items}",
    )
    _assert(
        str(probe.relation_formula_items[0].get("status")) != "invalid",
        f"edited right-hand dependency should remain valid: {probe.relation_formula_items}",
    )
    _assert(
        getattr(probe, "_last_relation_formula_refresh_affected_ids", []) == [1],
        f"edited right-hand dependency should mark the formula for reapply: {probe.relation_formula_items}",
    )

    old_model = _RelationFormulaRemapModel(
        {
            9: {"surface": "cylinder", "area_center": (0.5, 1.0, 9.5), "bbox_center": (0.5, 1.0, 9.5), "radius": 0.25, "area": 8.0},
            87: {"surface": "cylinder", "area_center": (2.0, 1.0, 9.5), "bbox_center": (2.0, 1.0, 9.5), "radius": 0.125, "area": 4.0},
        }
    )
    new_model = _RelationFormulaRemapModel(
        {
            1: {"surface": "cylinder", "area_center": (2.0, 1.0, 9.5), "bbox_center": (2.0, 1.0, 9.5), "radius": 0.5, "area": 16.0},
            9: {"surface": "cylinder", "area_center": (0.5, 1.0, 9.5), "bbox_center": (0.5, 1.0, 9.5), "radius": 0.4, "area": 12.8},
            11: {"surface": "cylinder", "area_center": (2.0, 1.0, 9.5), "bbox_center": (2.0, 1.0, 9.5), "radius": 0.125, "area": 4.0},
        }
    )
    new_model.face_logical_ids[9] = 9
    probe = _PropertyTableProbe()
    formula_text = "Face87.\u76f4\u5f84 = Face9.\u534a\u5f84"
    probe.model = old_model
    formula = parse_relation_formula(formula_text)
    probe.relation_formula_items = [
        {
            "id": 1,
            "text": formula_text,
            "enabled": True,
            "status": "applied",
            "message": "applied",
            "signatures": probe._relation_signatures_for_formula(formula),
        }
    ]
    probe.model = new_model
    probe._refresh_relation_formulas_after_model_edit(
        context={"target_kind": "face", "target_id": 9, "target_logical_id": 9}
    )
    _assert(
        probe.relation_formula_items[0]["text"] == "Face11.\u76f4\u5f84 = Face9.\u534a\u5f84",
        f"unchanged formula target should stay strict while a dependency changes: {probe.relation_formula_items}",
    )
    _assert(
        str(probe.relation_formula_items[0].get("status")) != "invalid",
        f"strict target remap should keep the dependency formula valid: {probe.relation_formula_items}",
    )
    _assert(
        getattr(probe, "_last_relation_formula_refresh_affected_ids", []) == [1],
        f"edited dependency should still queue the formula for reapply after target remap: {probe.relation_formula_items}",
    )

    def _unexpected_restore() -> bool:
        raise AssertionError("dependency relation replay must not restore the formula base snapshot")

    probe.relation_formula_base_snapshot = {"sentinel": object()}
    probe._restore_relation_formula_base_snapshot = _unexpected_restore
    probe._start_relation_formula_reapply(reason="dependency", restore_base=False, formula_ids=[1])
    _assert(
        [int(item.get("id", -1)) for item in probe.relation_formula_replay_queue] == [1],
        f"dependency replay should queue only the affected formula: {probe.relation_formula_replay_queue}",
    )
    probe.relation_formula_replay_active = False
    probe.relation_formula_replay_queue = []


def _assert_mouse_selection_guards() -> None:
    mouse_probe = _MouseSelectionProbe()
    mouse_probe._handle_left_button_press(20, 20)
    mouse_probe._handle_left_button_release(20, 20)
    _assert(
        [target.get("target_id") for target in mouse_probe.selected_targets] == [1],
        "plain left click should still select",
    )

    mouse_probe = _MouseSelectionProbe()
    mouse_probe._handle_left_button_press(20, 20)
    mouse_probe._update_left_button_drag_state(40, 20)
    mouse_probe._handle_left_button_release(40, 20)
    _assert(not mouse_probe.selected_targets, "left-button drag should not select a face on release")

    mouse_probe = _MouseSelectionProbe()
    mouse_probe._handle_left_button_press(20, 20)
    mouse_probe.camera_state = (0.5, 0.0, 9.8, 0.0, 0.0, 0.0, 0.02, 1.0, 0.0, 1.0, 9.8, 30.0)
    mouse_probe._handle_left_button_release(22, 21)
    _assert(
        not mouse_probe.selected_targets,
        "left-button camera rotation should not select a face even when the cursor lands on the model",
    )

    mouse_probe = _MouseSelectionProbe()
    mouse_probe.pick_targets = [None, {"kind": "face", "target_id": 1, "pick_position": (0.0, 0.0, 0.0)}]
    mouse_probe._handle_left_button_press(20, 20)
    mouse_probe._handle_left_button_release(20, 20)
    _assert(
        not mouse_probe.selected_targets,
        "left-button press on the background should not select a face on release",
    )

    mouse_probe = _MouseSelectionProbe()
    mouse_probe.pick_targets = [
        {"kind": "face", "target_id": 1, "pick_position": (0.0, 0.0, 0.0)},
        {"kind": "face", "target_id": 2, "pick_position": (0.0, 0.0, 0.0)},
    ]
    mouse_probe._handle_left_button_press(20, 20)
    mouse_probe._handle_left_button_release(20, 20)
    _assert(
        not mouse_probe.selected_targets,
        "left-button press/release on different faces should not change selection",
    )


def _assert_quick_blind_depth_spec() -> None:
    blind_probe = _PropertyTableProbe()
    blind_probe.selected_kind = "feature"
    blind_probe.selected_face_id = 6
    quick_blind_info = {
        "surface": "cylinder",
        "diameter": 4.0,
        "radius": 2.0,
        "axis_point": (0.0, 0.0, 0.0),
        "axis": (0.0, 0.0, 1.0),
        "axis_center": (0.0, 0.0, 3.0),
        "angular_span": math.tau,
        "feature_guess": "hole/groove candidate",
        "feature_type": "圆柱孔候选",
        "confidence": "medium",
        "cylinder_end_type": "blind",
        "hole_depth_estimate": 6.0,
        "depth_status": "ready",
        "recognition_ready_actions": "孔/槽/圆柱直径；盲孔/盲槽深度；封堵孔/槽",
    }
    blind_specs, _blind_used = blind_probe._editable_property_specs(quick_blind_info)
    blind_feature_specs = blind_probe._feature_property_specs(blind_specs, quick_blind_info)
    blind_axis_specs = [
        spec for spec in blind_feature_specs if str(spec.get("key", "")) == "hole_axis_center"
    ]
    _assert(blind_axis_specs, "quick blind hole axis center should be visible in feature parameters")
    blind_axis_spec = blind_axis_specs[0]
    _assert(str(blind_axis_spec.get("value_type", "")) == "vector3", "hole axis center should accept X/Y/Z")
    blind_axis_effective = blind_probe._effective_property_spec(blind_axis_spec)
    _assert(bool(blind_axis_effective.get("enabled")), "quick blind hole axis center should be editable")
    _assert(
        str(blind_axis_effective.get("action", "")) == "move_cylindrical_hole_axis",
        f"quick blind hole axis center should move the hole itself: {blind_axis_effective}",
    )
    blind_depth_specs = [
        spec for spec in blind_feature_specs if str(spec.get("key", "")) == "hole_depth_estimate"
    ]
    _assert(blind_depth_specs, "quick blind hole depth estimate should be visible in feature parameters")
    blind_depth_spec = blind_depth_specs[0]
    blind_effective_depth = blind_probe._effective_property_spec(blind_depth_spec)
    _assert(bool(blind_effective_depth.get("enabled")), "quick blind hole depth should be editable")
    _assert(
        str(blind_effective_depth.get("action", "")) == "resize_hole_depth",
        f"quick blind hole depth should use local depth edit first: {blind_effective_depth}",
    )
    _assert(
        "重新确认底面" in str(blind_effective_depth.get("enabled_tip", "")),
        "quick blind hole depth should explain execution-time bottom-face confirmation",
    )
    owning_mode = dict(blind_depth_spec.get("scope_modes", {})).get("owning", {})
    _assert(
        not bool(owning_mode.get("enabled")),
        "quick blind hole without explicit bottom faces should not expose owning-scale depth as editable",
    )


def _assert_user_facing_failure_messages() -> None:
    action_probe = _ActionMessageProbe()
    illegal_context = {
        "operation_name": "测试修改",
        "target": "Face 1",
        "parameters": {"resize_status": "blocked", "resize_blockers": "目标值必须大于 0。"},
    }
    illegal_blocker = action_probe._edit_preflight_blocker(illegal_context)
    _assert(illegal_blocker is not None, "blocked edit plan should be stopped before worker startup")
    _assert(illegal_blocker[0] == "当前操作不合法", "illegal blocked edit should be classified clearly")
    english_illegal_context = {
        "operation_name": "调整槽宽",
        "target": "Face 3",
        "parameters": {"resize_status": "blocked", "resize_blockers": "Target slot value must be greater than 0."},
    }
    english_illegal_blocker = action_probe._edit_preflight_blocker(english_illegal_context)
    _assert(
        english_illegal_blocker is not None and english_illegal_blocker[0] == "当前操作不合法",
        "english geometry blockers should also be classified as illegal operations",
    )
    risk_blocker = action_probe._plan_preflight_blocker(
        {"status": "blocked", "risk": "blocked", "message": "目标壳体厚度会让几何风险过高。"}
    )
    _assert(risk_blocker is not None and risk_blocker[0] == "风险过高", "blocked high-risk plans should be classified")
    recognition_blocker = action_probe._plan_preflight_blocker(
        {"status": "blocked", "message": "当前平面没有识别到相对壳体平面。"}
    )
    _assert(
        recognition_blocker is not None and recognition_blocker[0] == "识别不足",
        "blocked recognition failures should be classified",
    )
    unsupported_blocker = action_probe._plan_preflight_blocker(
        {"status": "blocked", "message": "当前版本只对简单圆锥解析重建开放这类修改。"}
    )
    _assert(
        unsupported_blocker is not None and unsupported_blocker[0] == "暂未实现",
        "blocked unsupported capability plans should be classified",
    )
    auxiliary_context = {
        "operation_name": "测试修改",
        "target": "Face 4",
        "parameters": {"quick_plan_status": "blocked", "resize_status": "ready", "resize_blockers": ""},
    }
    _assert(action_probe._edit_preflight_blocker(auxiliary_context) is None, "auxiliary statuses should not block ready edits")

    deferred_context = {
        "operation_name": "复杂 Face 修改",
        "target": "Face 2",
        "parameters": {"ui_deferred_model_plan": True, "message": "当前对象需要完整一级关系计划。"},
    }
    deferred_blocker = action_probe._edit_preflight_blocker(deferred_context)
    _assert(deferred_blocker is not None, "deferred model plan should be stopped before slow worker startup")
    _assert(deferred_blocker[0] == "暂未实现", "deferred model plan should be classified as unsupported")

    title, user_message = action_probe._user_facing_edit_failure_message(
        "隔离子进程执行失败；主程序没有崩溃，原模型保持不变。 当前版本暂不支持复杂链式圆角。",
        deferred_context,
    )
    _assert(title == "不能修改", "edit failure dialog title should be user-facing")
    _assert("隔离子进程" not in user_message and "子进程" not in user_message, "failure message should not expose isolation details")
    _assert("暂未实现" in user_message, "unsupported failure should state that the operation is not implemented yet")
    _empty_title, empty_message = action_probe._user_facing_edit_failure_message(
        "隔离子进程执行失败；主程序没有崩溃，原模型保持不变。",
        deferred_context,
    )
    _assert("隔离子进程" not in empty_message and "子进程" not in empty_message, "empty internal failure should stay user-facing")


def _assert_parameter_export_action() -> None:
    with tempfile.TemporaryDirectory() as temp_dir:
        output_path = Path(temp_dir) / "data.json"
        probe = _ParameterExportActionProbe(output_path)
        probe.export_selected_parameters()
        payload = json.loads(output_path.read_text(encoding="utf-8"))
        component_text = probe.component_path.read_text(encoding="utf-8")
    _assert(
        payload == [
            {
                "name": "面内长度",
                "displayName": "面内长度",
                "type": "number",
                "ioRole": "input",
                "default": "151",
            },
            {
                "name": "偏移",
                "displayName": "偏移",
                "type": "number",
                "ioRole": "input",
                "default": "57.5",
            },
        ],
        f"parameter export action wrote unexpected JSON: {payload}",
    )
    _assert(
        "INPUT_PARAMETERS" in component_text and "def execute(inputs, params, context):" in component_text and "面内长度" in component_text,
        "parameter export should generate FlowEditor-style component main.py with embedded input parameters",
    )
    _assert(
        not (probe.component_path.parent / "data.json").exists(),
        "component export should embed parameters in main.py instead of writing component data.json",
    )
    _assert(
        probe.status_bar.messages and "已导出 2 个输入参数" in probe.status_bar.messages[-1],
        "parameter export status should mention exported count",
    )
    _assert(
        "data.json" in probe.info_text and "参数数量：2" in probe.info_text and "组件入口：main.py" in probe.info_text,
        "parameter export info panel summary should mention generated component",
    )


def main() -> int:
    app = QApplication.instance() or QApplication([])
    top_level_label_probe = _TopLevelPropertyLabelProbe()
    app.installEventFilter(top_level_label_probe)

    probe = _PropertyTableProbe()
    probe.show()
    QApplication.processEvents()
    probe._refresh_property_editor()
    QApplication.processEvents()
    _assert(
        not top_level_label_probe.shown_labels,
        f"property labels were shown as transient top-level windows: {top_level_label_probe.shown_labels}",
    )
    _assert_property_table_editor(probe)
    _assert("当前支持" in probe.current_capability_headline.text(), "software progress panel did not show supported areas")
    _assert("优先：" not in probe.current_capability_headline.text(), "software progress panel should not show priority copy")
    _assert(
        "矩形槽口袋" in probe.current_capability_headline.toolTip()
        and "多台阶矩形凸台顶层" in probe.current_capability_headline.toolTip(),
        "software progress tooltip should name newly supported prismatic feature edits",
    )

    _assert_diagnostics_stay_out_of_parameter_table(probe)
    _assert_relation_formula_editor()
    _assert_relation_radius_formula_proxy()
    _assert_relation_formula_input_remains_editable_while_replaying()
    _assert_relation_formula_input_clickable_after_existing_formula()
    _assert_relation_formula_input_is_selection_independent()
    _assert_relation_formula_input_recovers_after_loading()
    _assert_relation_formula_ids_follow_model_remap()
    _assert_mouse_selection_guards()
    _assert_quick_blind_depth_spec()
    _assert_user_facing_failure_messages()
    _assert_parameter_export_action()

    print("property table editor UI ok")
    if QApplication.instance() is app:
        app.quit()
    return 0


if __name__ == "__main__":
    raise SystemExit(main())