suyu
/
suyu_two
1
0
Fork 0
Code Issues 0 Pull Requests 0 Releases 0 Wiki Activity
综合平台编程器项目的远程存储
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
138 Commits
1 Branch
183 MiB
 
 
 
 
Tree: 61e3022da3
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '61e3022da3'
${ noResults }
suyu_two/app/tests/runtime_panel_controller_te...

1003 lines
40 KiB
Raw Blame History 

  1. #include "domain/virtual_register_repository.h"

  2. #include "services/alarm_editor_service.h"

  3. #include "services/alarm_service.h"

  4. #include "services/hmi_editor_service.h"

  5. #include "services/hmi_navigation_service.h"

  6. #include "services/hmi_runtime_service.h"

  7. #include "services/logic_editor_service.h"

  8. #include "services/offline_simulation_service.h"

  9. #include "services/project_service.h"

  10. #include "services/register_monitor_service.h"

  11. #include "services/runtime_mode_service.h"

  12. #include "support/test_support.h"

  13. #include "ui/alarm_configuration_dialog.h"

  14. #include "ui/free_monitor_widget.h"

  15. #include "ui/hmi_editor_widget.h"

  16. #include "ui/logic_editor_widget.h"

  17. #include "ui/runtime_monitor_widget.h"

  18. #include "ui/runtime_panel_controller.h"

  19. 

  20. #include <QApplication>

  21. #include <QCoreApplication>

  22. #include <QEventLoop>

  23. #include <QGraphicsLineItem>

  24. #include <QGraphicsRectItem>

  25. #include <QGraphicsScene>

  26. #include <QGraphicsSimpleTextItem>

  27. #include <QImage>

  28. #include <QKeyEvent>

  29. #include <QLabel>

  30. #include <QLineEdit>

  31. #include <QComboBox>

  32. #include <QMouseEvent>

  33. #include <QPainter>

  34. #include <QWidget>

  35. 

  36. #include <algorithm>

  37. #include <iostream>

  38. #include <stdexcept>

  39. #include <string>

  40. 

  41. namespace {

  42. 

  43. using TestProjectStorage = TestSupport::InMemoryProjectStorage;

  44. using TestSupport::require;

  45. 

  46. ControlLogic makeAlwaysOnLogic()

  47. {

  48.     ControlLogic logic;

  49.     logic.id = "queued-trace-logic";

  50.     logic.name = "Queued trace logic";

  51. 

  52.     LadderRung rung;

  53.     rung.id = "always-on-rung";

  54.     rung.name = "Always on";

  55.     for (int column = 0;

  56.          column < ProjectLimits::kMaximumConditionColumns;

  57.          ++column)

  58.     {

  59.         rung.cells.push_back({

  60.             "always-on-cell-" + std::to_string(column),

  61.             LadderCellKind::Wire,

  62.             std::nullopt});

  63.     }

  64. 

  65.     LogicNode output;

  66.     output.id = "always-on-output";

  67.     output.config = CoilNodeConfig{

  68.         RegisterAddress{RegisterArea::M, 1}, CoilMode::Normal};

  69.     rung.output = output;

  70.     logic.rungs.push_back(rung);

  71.     return logic;

  72. }

  73. 

  74. void testMonitorOffersAllNumericTypes()

  75. {

  76.     VirtualRegisterRepository repository;

  77.     RegisterMonitorService service(repository);

  78.     FreeMonitorWidget widget(service);

  79.     QComboBox *type_combo = widget.findChild<QComboBox *>(

  80.         QStringLiteral("dataTypeComboBox"));

  81.     require(type_combo != nullptr

  82.                 && type_combo->count() == 4

  83.                 && type_combo->itemData(0).toInt()

  84.                     == static_cast<int>(RegisterDataType::Int16)

  85.                 && type_combo->itemData(1).toInt()

  86.                     == static_cast<int>(RegisterDataType::Int32)

  87.                 && type_combo->itemData(2).toInt()

  88.                     == static_cast<int>(RegisterDataType::Float32)

  89.                 && type_combo->itemData(3).toInt()

  90.                     == static_cast<int>(RegisterDataType::Float64)

  91.                 && type_combo->itemText(3)

  92.                     == QStringLiteral("Double (Float64)"),

  93.             "shared data/free monitor UI must expose all four numeric types");

  94. }

  95. 

  96. void testAlarmConfigurationOffersMOnAndMOff()

  97. {

  98.     TestProjectStorage storage;

  99.     ProjectService project_service(storage);

  100.     AlarmEditorService alarm_editor_service(project_service);

  101.     AlarmConfigurationDialog dialog(alarm_editor_service);

  102. 

  103.     QComboBox *area_combo = dialog.findChild<QComboBox *>(

  104.         QStringLiteral("areaComboBox"));

  105.     QComboBox *condition_combo = dialog.findChild<QComboBox *>(

  106.         QStringLiteral("conditionComboBox"));

  107.     require(area_combo != nullptr && condition_combo != nullptr,

  108.             "alarm configuration must expose its area and condition inputs");

  109.     require(area_combo->currentData().toInt()

  110.                 == static_cast<int>(RegisterArea::M)

  111.                 && condition_combo->count() == 2

  112.                 && condition_combo->findData(

  113.                     static_cast<int>(AlarmCondition::MOn)) >= 0

  114.                 && condition_combo->findData(

  115.                     static_cast<int>(AlarmCondition::MOff)) >= 0

  116.                 && condition_combo->findText(QStringLiteral("M 为 ON")) >= 0

  117.                 && condition_combo->findText(QStringLiteral("M 为 OFF")) >= 0,

  118.             "M alarm configuration must offer both ON and OFF conditions");

  119. }

  120. 

  121. void testAlarmListKeepsFixedGeometryWhileRecordsChange()

  122. {

  123.     TestProjectStorage storage;

  124.     ProjectService project_service(storage);

  125.     VirtualRegisterRepository virtual_repository;

  126.     HmiEditorService hmi_editor_service(project_service);

  127.     HmiRuntimeService hmi_runtime_service(virtual_repository);

  128.     AlarmService alarm_service(project_service, virtual_repository);

  129. 

  130.     const HmiEditorResult page = hmi_editor_service.ensureDefaultPage();

  131.     const HmiEditorResult alarm_list = hmi_editor_service.addControl(

  132.         page.id, HmiControlType::AlarmList);

  133.     require(page.succeeded && alarm_list.succeeded,

  134.             "alarm-list fixture must create a page and control");

  135.     project_service.editProject().alarmDefinitions.push_back({

  136.         "fixed-alarm",

  137.         RegisterAddress{RegisterArea::M, 0},

  138.         AlarmCondition::MOn,

  139.         0,

  140.         "Fixed alarm"});

  141. 

  142.     HmiEditorWidget widget(

  143.         hmi_editor_service, hmi_runtime_service, alarm_service);

  144.     widget.setPageId(page.id);

  145.     widget.setEditingEnabled(false);

  146.     widget.setRuntimeActive(true);

  147.     widget.refreshRuntimeValues();

  148. 

  149.     QGraphicsItem *alarm_item = nullptr;

  150.     for (QGraphicsItem *item : widget.scene()->items())

  151.     {

  152.         if (dynamic_cast<QGraphicsRectItem *>(item) == nullptr)

  153.         {

  154.             alarm_item = item;

  155.             break;

  156.         }

  157.     }

  158.     const HmiControl *control = hmi_editor_service.findControl(

  159.         page.id, alarm_list.id);

  160.     require(alarm_item != nullptr && control != nullptr,

  161.             "runtime HMI scene must contain the alarm-list item");

  162.     const QRectF fixed_bounds = alarm_item->boundingRect();

  163.     require(alarm_item->isVisible()

  164.                 && qFuzzyCompare(

  165.                     fixed_bounds.width() + 1.0,

  166.                     static_cast<qreal>(control->bounds.width) + 1.0)

  167.                 && qFuzzyCompare(

  168.                     fixed_bounds.height() + 1.0,

  169.                     static_cast<qreal>(control->bounds.height) + 1.0),

  170.             "an empty runtime alarm list must remain visible at its configured size");

  171. 

  172.     require(virtual_repository.writeBit(

  173.                 RegisterAddress{RegisterArea::M, 0}, true).succeeded,

  174.             "alarm-list fixture must activate M0");

  175.     alarm_service.refresh();

  176.     widget.refreshRuntimeValues();

  177.     require(alarm_service.records().size() == 1U

  178.                 && alarm_item->isVisible()

  179.                 && alarm_item->boundingRect() == fixed_bounds,

  180.             "adding an alarm row must not resize or hide the alarm control");

  181. 

  182.     require(virtual_repository.writeBit(

  183.                 RegisterAddress{RegisterArea::M, 0}, false).succeeded,

  184.             "alarm-list fixture must restore M0");

  185.     alarm_service.refresh();

  186.     widget.refreshRuntimeValues();

  187.     require(alarm_service.records().empty()

  188.                 && alarm_item->isVisible()

  189.                 && alarm_item->boundingRect() == fixed_bounds,

  190.             "removing the last alarm row must keep the fixed alarm control visible");

  191. }

  192. 

  193. void testQueuedOfflineTraceIsIgnoredAfterReturningToEditing()

  194. {

  195.     TestProjectStorage storage;

  196.     ProjectService project_service(storage);

  197.     VirtualRegisterRepository virtual_repository;

  198.     OfflineSimulationService simulation_service(virtual_repository);

  199.     OnlineLogicMonitorService online_monitor_service(virtual_repository);

  200.     LogicEditorService logic_editor_service(project_service);

  201.     RuntimeModeService runtime_mode_service(

  202.         project_service,

  203.         logic_editor_service,

  204.         simulation_service,

  205.         online_monitor_service);

  206.     HmiEditorService hmi_editor_service(project_service);

  207.     HmiRuntimeService hmi_runtime_service(virtual_repository);

  208.     HmiNavigationService hmi_navigation_service(project_service);

  209.     AlarmService alarm_service(project_service, virtual_repository);

  210.     RegisterMonitorService register_monitor_service(virtual_repository);

  211. 

  212.     const ControlLogic logic = makeAlwaysOnLogic();

  213.     project_service.editProject().controlLogics.push_back(logic);

  214. 

  215.     QWidget parent;

  216.     HmiEditorWidget hmi_editor_widget(

  217.         hmi_editor_service, hmi_runtime_service, alarm_service, &parent);

  218.     LogicEditorWidget logic_editor_widget(logic_editor_service, &parent);

  219.     QLabel executor_status_label(&parent);

  220.     std::string current_logic_id = logic.id;

  221.     logic_editor_widget.setLogicId(current_logic_id);

  222. 

  223.     RuntimePanelController controller(

  224.         parent,

  225.         runtime_mode_service,

  226.         project_service,

  227.         hmi_editor_service,

  228.         hmi_runtime_service,

  229.         logic_editor_service,

  230.         hmi_navigation_service,

  231.         alarm_service,

  232.         register_monitor_service,

  233.         hmi_editor_widget,

  234.         logic_editor_widget,

  235.         executor_status_label,

  236.         [&current_logic_id] { return current_logic_id; },

  237.         [&current_logic_id](const std::string &logic_id)

  238.         {

  239.             current_logic_id = logic_id;

  240.         },

  241.         [](const std::string &) {},

  242.         [](const QString &, int) {},

  243.         [](const QString &) {},

  244.         [] {});

  245.     controller.configure();

  246. 

  247.     require(runtime_mode_service.enterOfflineRunning().succeeded,

  248.             "offline simulation must start for queued trace regression");

  249.     controller.enterRuntime(

  250.         {}, logic.id, runtime_mode_service.mode(),

  251.         runtime_mode_service.plcConnectionState());

  252.     QLabel *logic_label = controller.runtimeMonitorWidget()

  253.         ->findChild<QLabel *>(QStringLiteral("logicLabel"));

  254.     QLabel *notice_label = controller.runtimeMonitorWidget()

  255.         ->findChild<QLabel *>(QStringLiteral("logicNoticeLabel"));

  256.     require(logic_label != nullptr && notice_label != nullptr,

  257.             "runtime monitor must expose its local trace labels");

  258.     require(logic_label->text() == QStringLiteral("梯形图运行状态")

  259.                 && !notice_label->isVisible(),

  260.             "offline runtime must keep the normal ladder trace heading");

  261.     controller.runtimeMonitorWidget()->setMode(

  262.         ApplicationMode::OnlineRunning, PlcConnectionState::Connected);

  263.     require(logic_label->text() == QStringLiteral("本地推算轨迹")

  264.                 && notice_label->isVisible()

  265.                 && notice_label->text().contains(QStringLiteral("不写入 PLC 程序或 M/D"))

  266.                 && notice_label->text().contains(QStringLiteral("HMI 和自由监控仍可写 PLC")),

  267.             "online runtime must explain the read-only local trace boundary");

  268.     controller.runtimeMonitorWidget()->setMode(

  269.         ApplicationMode::OfflineRunning, PlcConnectionState::Disconnected);

  270.     require(simulation_service.executeOnce().succeeded,

  271.             "offline simulation must produce a trace before editing");

  272.     require(simulation_service.traceSnapshot()

  273.                 .forLogic(logic.id).rungValues.at("always-on-rung"),

  274.             "the queued trace must contain an energized rung");

  275.     QCoreApplication::processEvents(QEventLoop::AllEvents);

  276.     LogicEditorWidget *runtime_logic_view = controller.runtimeMonitorWidget()

  277.         ->findChild<LogicEditorWidget *>(QStringLiteral("runtimeLogicView"));

  278.     bool found_active_runtime_output = false;

  279.     require(runtime_logic_view != nullptr,

  280.             "runtime monitor must own the ladder trace view");

  281.     for (QGraphicsItem *item : runtime_logic_view->scene()->items())

  282.     {

  283.         if (item->data(0).toString() == QStringLiteral("output")

  284.             && item->data(1).toString()

  285.                     == QStringLiteral("always-on-rung"))

  286.         {

  287.             found_active_runtime_output = item->data(3).toBool()

  288.                 && item->data(4).toBool();

  289.         }

  290.     }

  291.     require(found_active_runtime_output,

  292.             "the full executor snapshot must reach the runtime ladder exactly once");

  293. 

  294.     require(simulation_service.executeOnce().succeeded,

  295.             "a second scan must queue the stale-trace regression event");

  296. 

  297.     require(runtime_mode_service.enterEditing().succeeded,

  298.             "offline simulation must return to editing before queued delivery");

  299.     controller.leaveRuntime(

  300.         runtime_mode_service.mode(), runtime_mode_service.plcConnectionState());

  301.     logic_editor_widget.clearRuntimeTrace();

  302.     require(!logic_editor_widget.runtimeTraceEnabled(),

  303.             "editing transition must initially clear the runtime trace");

  304. 

  305.     QCoreApplication::processEvents(QEventLoop::AllEvents);

  306.     require(!logic_editor_widget.runtimeTraceEnabled(),

  307.             "a queued offline scan must not restore the trace after returning to editing");

  308. }

  309. 

  310. void testLogicEditorGridSelectionAndDeletion()

  311. {

  312.     TestProjectStorage storage;

  313.     ProjectService project_service(storage);

  314.     LogicEditorService logic_editor_service(project_service);

  315.     const std::string logic_id = logic_editor_service.ensureDefaultLogic().id;

  316. 

  317.     LogicEditorWidget widget(logic_editor_service);

  318.     widget.setLogicId(logic_id);

  319.     require(widget.scene()->items().isEmpty(),

  320.             "an empty logic must not draw standalone power rails");

  321.     require((widget.alignment() & Qt::AlignLeft) != 0

  322.                 && (widget.alignment() & Qt::AlignTop) != 0,

  323.             "the ladder canvas must start at its top-left origin");

  324. 

  325.     const std::string rung_id = logic_editor_service.addRung(logic_id).id;

  326.     require(!rung_id.empty(), "the grid regression fixture must create a row");

  327.     require(logic_editor_service.setHorizontalWireRange(

  328.                 logic_id, rung_id, 4, 4, true).succeeded,

  329.             "the grid regression fixture must draw one horizontal cell");

  330.     widget.reloadLogic();

  331.     widget.resize(1200, 400);

  332.     widget.show();

  333.     QCoreApplication::processEvents(QEventLoop::AllEvents);

  334. 

  335.     constexpr qreal left_bus = 60.0;

  336.     constexpr qreal cell_width = 96.0;

  337.     constexpr qreal output_width = 224.0;

  338.     constexpr qreal first_grid_top = 46.0;

  339.     constexpr qreal row_height = 78.0;

  340.     const auto clickScene = [&widget](const QPointF &position,

  341.                                       Qt::KeyboardModifiers modifiers = Qt::NoModifier)

  342.     {

  343.         const QPoint point = widget.mapFromScene(position);

  344.         QMouseEvent press(

  345.             QEvent::MouseButtonPress,

  346.             QPointF(point),

  347.             Qt::LeftButton,

  348.             Qt::LeftButton,

  349.             modifiers);

  350.         QApplication::sendEvent(widget.viewport(), &press);

  351.         QMouseEvent release(

  352.             QEvent::MouseButtonRelease,

  353.             QPointF(point),

  354.             Qt::LeftButton,

  355.             Qt::NoButton,

  356.             modifiers);

  357.         QApplication::sendEvent(widget.viewport(), &release);

  358.     };

  359.     const auto dragScene = [&widget](

  360.         const QPointF &from,

  361.         const QPointF &to,

  362.         Qt::KeyboardModifiers modifiers = Qt::NoModifier)

  363.     {

  364.         const QPoint from_point = widget.mapFromScene(from);

  365.         const QPoint to_point = widget.mapFromScene(to);

  366.         QMouseEvent press(

  367.             QEvent::MouseButtonPress,

  368.             QPointF(from_point),

  369.             Qt::LeftButton,

  370.             Qt::LeftButton,

  371.             modifiers);

  372.         QApplication::sendEvent(widget.viewport(), &press);

  373.         QMouseEvent move(

  374.             QEvent::MouseMove,

  375.             QPointF(to_point),

  376.             Qt::NoButton,

  377.             Qt::LeftButton,

  378.             modifiers);

  379.         QApplication::sendEvent(widget.viewport(), &move);

  380.         QMouseEvent release(

  381.             QEvent::MouseButtonRelease,

  382.             QPointF(to_point),

  383.             Qt::LeftButton,

  384.             Qt::NoButton,

  385.             modifiers);

  386.         QApplication::sendEvent(widget.viewport(), &release);

  387.     };

  388.     clickScene(QPointF(

  389.         left_bus + 4.0 * cell_width + cell_width / 2.0,

  390.         first_grid_top + row_height / 2.0));

  391. 

  392.     require(widget.selectedRungId() == rung_id,

  393.             "clicking a grid cell must select its row");

  394.     QString delete_error;

  395.     QObject::connect(

  396.         &widget,

  397.         &LogicEditorWidget::editorError,

  398.         [&delete_error](const QString &message) { delete_error = message; });

  399.     const LogicEditorResult deleted = widget.deleteSelected();

  400.     require(deleted.succeeded,

  401.             "Delete on a selected horizontal cell must succeed: "

  402.                 + delete_error.toStdString());

  403.     const LadderRung *rung = logic_editor_service.findRung(logic_id, rung_id);

  404.     require(rung != nullptr && rung->cells.size() == 10U

  405.                 && rung->cells[4].kind == LadderCellKind::Gap,

  406.             "Delete on one horizontal cell must preserve the row and clear only that cell");

  407. 

  408.     widget.clearSelection();

  409.     require(widget.selectedRungId().empty(),

  410.             "clearing the selection must not expose the first row as selected");

  411.     require(!widget.addHorizontalWire().succeeded,

  412.             "the horizontal-wire command must require an explicitly selected cell");

  413. 

  414.     require(logic_editor_service.setHorizontalWireRange(

  415.                 logic_id, rung_id, 3, 3, true).succeeded,

  416.             "fixture must restore a wire for precise hit testing");

  417.     widget.reloadLogic();

  418.     clickScene(QPointF(

  419.         left_bus + 3.0 * cell_width,

  420.         first_grid_top + row_height / 2.0));

  421.     require(!widget.deleteSelected().succeeded,

  422.             "Delete on a column boundary must not delete an adjacent cell");

  423.     require(logic_editor_service.findRung(logic_id, rung_id)->cells[3].kind

  424.                 == LadderCellKind::Wire,

  425.             "a boundary selection must preserve the adjacent horizontal wire");

  426. 

  427.     clickScene(QPointF(

  428.         left_bus + 10.0 * cell_width + output_width / 2.0,

  429.         first_grid_top + row_height / 2.0));

  430.     require(!widget.deleteSelected().succeeded

  431.                 && logic_editor_service.findLogic(logic_id)->rungs.size() == 1U,

  432.             "Delete on an empty output slot must never delete the whole row");

  433. 

  434.     clickScene(QPointF(

  435.         left_bus + 2.0 * cell_width + cell_width / 2.0,

  436.         first_grid_top + row_height / 2.0));

  437.     require(widget.addHorizontalWire().succeeded

  438.                 && logic_editor_service.findRung(logic_id, rung_id)->cells[2].kind

  439.                     == LadderCellKind::Wire,

  440.             "the horizontal-wire command must act on an explicitly selected cell");

  441. 

  442.     const LogicEditorResult first_node = logic_editor_service.setConditionAtColumn(

  443.         logic_id,

  444.         rung_id,

  445.         0,

  446.         ContactNodeConfig{

  447.             RegisterAddress{RegisterArea::M, 0},

  448.             ContactMode::NormallyOpen},

  449.         true);

  450.     const LogicEditorResult second_node = logic_editor_service.setConditionAtColumn(

  451.         logic_id,

  452.         rung_id,

  453.         1,

  454.         ContactNodeConfig{

  455.             RegisterAddress{RegisterArea::M, 1},

  456.             ContactMode::NormallyOpen},

  457.         true);

  458.     require(first_node.succeeded && second_node.succeeded,

  459.             "fixture must create adjacent conditions for multi-selection");

  460.     widget.reloadLogic();

  461.     dragScene(

  462.         QPointF(left_bus + 5.0, first_grid_top + 5.0),

  463.         QPointF(

  464.             left_bus + 2.0 * cell_width - 5.0,

  465.             first_grid_top + row_height - 5.0));

  466.     require(widget.selectedNodeIds().size() == 2U,

  467.             "mouse drag must select multiple conditions in the same row");

  468.     widget.clearSelection();

  469.     clickScene(QPointF(

  470.         left_bus + cell_width / 2.0,

  471.         first_grid_top + row_height / 2.0));

  472.     dragScene(

  473.         QPointF(left_bus + cell_width + 5.0, first_grid_top + 5.0),

  474.         QPointF(

  475.             left_bus + 2.0 * cell_width - 5.0,

  476.             first_grid_top + row_height - 5.0),

  477.         Qt::ControlModifier);

  478.     require(widget.selectedNodeIds().size() == 2U,

  479.             "Ctrl-drag must append objects to the existing selection");

  480.     require(widget.addParallelBranch(ContactNodeConfig{

  481.                 RegisterAddress{RegisterArea::M, 2},

  482.                 ContactMode::NormallyOpen}).succeeded

  483.                 && logic_editor_service.findLogic(logic_id)->rungs.size() == 2U,

  484.             "parallel insertion must use the explicitly selected condition range");

  485.     const LogicEditorResult output = logic_editor_service.setOutput(

  486.         logic_id,

  487.         rung_id,

  488.         CoilNodeConfig{

  489.             RegisterAddress{RegisterArea::M, 3}, CoilMode::Normal},

  490.         true);

  491.     require(output.succeeded,

  492.             "syntax-location fixture must create an output instruction");

  493.     widget.reloadLogic();

  494.     widget.focusSyntaxLocation(

  495.         rung_id, ProjectLimits::kMaximumLadderColumns);

  496.     require(

  497.         widget.selectedRungId() == rung_id

  498.             && widget.selectedNodeId() == output.id,

  499.         "a syntax error at column 11 must focus the output slot");

  500.     widget.focusSyntaxLocation(rung_id, 1);

  501.     require(

  502.         widget.selectedRungId() == rung_id

  503.             && widget.selectedNodeId() == first_node.id,

  504.         "a syntax error in the condition area must focus its one-based column");

  505. }

  506. 

  507. void testLadderLayoutAndDragDeletion()

  508. {

  509.     TestProjectStorage storage;

  510.     ProjectService project_service(storage);

  511.     LogicEditorService editor(project_service);

  512.     const std::string logic_id = editor.ensureDefaultLogic().id;

  513.     const std::string upper = editor.addRung(logic_id).id;

  514.     const std::string lower = editor.addRung(logic_id).id;

  515.     require(

  516.         editor.setConditionAtColumn(

  517.             logic_id,

  518.             upper,

  519.             0,

  520.             ContactNodeConfig{

  521.                 RegisterAddress{RegisterArea::M, 10},

  522.                 ContactMode::NormallyClosed},

  523.             true).succeeded

  524.             && editor.setHorizontalWireRange(

  525.                 logic_id, upper, 1, 1, true).succeeded

  526.             && editor.setOutput(

  527.                 logic_id,

  528.                 upper,

  529.                 MoveNodeConfig{

  530.                     WordOperand{

  531.                         WordOperandKind::Register,

  532.                         RegisterAddress{RegisterArea::D, 10},

  533.                         0},

  534.                     RegisterAddress{RegisterArea::D, 20}},

  535.                 true).succeeded

  536.             && editor.setHorizontalWireRange(

  537.                 logic_id, lower, 0, 1, true).succeeded

  538.             && editor.setVerticalConnection(

  539.                 logic_id, upper, lower, 2, true).succeeded

  540.             && editor.updateRungComment(

  541.                 logic_id, upper, "主网络注释").succeeded

  542.             && editor.updateRungComment(

  543.                 logic_id, lower, "支路注释不应重复").succeeded,

  544.         "layout fixture must create a connected two-row network");

  545.     editor.clearHistory();

  546. 

  547.     LogicEditorWidget widget(editor);

  548.     widget.setLogicId(logic_id);

  549.     widget.resize(1320, 360);

  550.     widget.show();

  551.     QCoreApplication::processEvents(QEventLoop::AllEvents);

  552. 

  553.     bool found_head_comment = false;

  554.     bool found_branch_comment = false;

  555.     for (QGraphicsItem *item : widget.scene()->items())

  556.     {

  557.         auto *text = dynamic_cast<QGraphicsSimpleTextItem *>(item);

  558.         if (text == nullptr)

  559.         {

  560.             continue;

  561.         }

  562.         found_head_comment = found_head_comment

  563.             || text->text() == QStringLiteral("主网络注释");

  564.         found_branch_comment = found_branch_comment

  565.             || text->text() == QStringLiteral("支路注释不应重复");

  566.     }

  567.     require(found_head_comment && !found_branch_comment,

  568.             "only the network-head comment must be rendered");

  569. 

  570.     constexpr qreal left_bus = 60.0;

  571.     constexpr qreal cell_width = 96.0;

  572.     constexpr qreal right_bus = left_bus + 10.0 * cell_width + 224.0;

  573.     constexpr qreal first_grid_top = 46.0;

  574.     constexpr qreal second_grid_bottom = first_grid_top + 2.0 * 78.0;

  575.     QImage grid_image(1320, 360, QImage::Format_ARGB32_Premultiplied);

  576.     grid_image.fill(Qt::transparent);

  577.     {

  578.         QPainter painter(&grid_image);

  579.         widget.scene()->render(

  580.             &painter,

  581.             QRectF(0.0, 0.0, 1320.0, 360.0),

  582.             QRectF(0.0, 0.0, 1320.0, 360.0),

  583.             Qt::IgnoreAspectRatio);

  584.     }

  585.     const auto background_at = [&grid_image, first_grid_top](qreal x)

  586.     {

  587.         return grid_image.pixelColor(

  588.             qRound(x), qRound(first_grid_top + 68.0));

  589.     };

  590.     const QColor node_background = background_at(

  591.         left_bus + cell_width - 10.0);

  592.     const QColor wire_background = background_at(

  593.         left_bus + 2.0 * cell_width - 10.0);

  594.     const QColor gap_background = background_at(

  595.         left_bus + 3.0 * cell_width - 10.0);

  596.     const QColor output_background = background_at(right_bus - 10.0);

  597.     require(

  598.         node_background == QColor(QStringLiteral("#ffffff"))

  599.             && node_background == wire_background

  600.             && wire_background == gap_background

  601.             && gap_background == output_background,

  602.         "node, wire, gap, and output cells must share one grid background");

  603. 

  604.     bool found_left_rail = false;

  605.     bool found_right_rail = false;

  606.     for (QGraphicsItem *item : widget.scene()->items())

  607.     {

  608.         auto *line_item = dynamic_cast<QGraphicsLineItem *>(item);

  609.         if (line_item == nullptr || line_item->data(0).isValid())

  610.         {

  611.             continue;

  612.         }

  613.         const QLineF line = line_item->line();

  614.         const bool exact_span = qFuzzyCompare(

  615.                 line.y1() + 1.0, first_grid_top + 1.0)

  616.             && qFuzzyCompare(

  617.                 line.y2() + 1.0, second_grid_bottom + 1.0);

  618.         found_left_rail = found_left_rail

  619.             || (exact_span && qFuzzyCompare(

  620.                 line.x1() + 1.0, left_bus + 1.0));

  621.         found_right_rail = found_right_rail

  622.             || (exact_span && qFuzzyCompare(

  623.                 line.x1() + 1.0, right_bus + 1.0));

  624.     }

  625.     require(found_left_rail && found_right_rail,

  626.             "both rails must share the exact first-to-last row span");

  627. 

  628.     const QPoint from = widget.mapFromScene(

  629.         QPointF(left_bus + 4.0, first_grid_top + 4.0));

  630.     const QPoint to = widget.mapFromScene(

  631.         QPointF(right_bus - 4.0, second_grid_bottom - 4.0));

  632.     QMouseEvent press(

  633.         QEvent::MouseButtonPress,

  634.         QPointF(from),

  635.         Qt::LeftButton,

  636.         Qt::LeftButton,

  637.         Qt::NoModifier);

  638.     QApplication::sendEvent(widget.viewport(), &press);

  639.     QMouseEvent move(

  640.         QEvent::MouseMove,

  641.         QPointF(to),

  642.         Qt::NoButton,

  643.         Qt::LeftButton,

  644.         Qt::NoModifier);

  645.     QApplication::sendEvent(widget.viewport(), &move);

  646.     QMouseEvent release(

  647.         QEvent::MouseButtonRelease,

  648.         QPointF(to),

  649.         Qt::LeftButton,

  650.         Qt::NoButton,

  651.         Qt::NoModifier);

  652.     QApplication::sendEvent(widget.viewport(), &release);

  653.     require(widget.selectedNodeIds().size() == 2U,

  654.             "drag selection must include the condition and output instruction");

  655.     const QList<QGraphicsItem *> selected_scene_items = widget.scene()->items();

  656.     require(

  657.         std::any_of(

  658.             selected_scene_items.cbegin(),

  659.             selected_scene_items.cend(),

  660.             [](QGraphicsItem *item) { return item->zValue() == 100.0; }),

  661.         "selected objects must be painted by the highest selection layer");

  662. 

  663.     require(widget.deleteSelected().succeeded,

  664.             "Delete must submit the complete drag selection once");

  665.     const LadderRung *upper_rung = editor.findRung(logic_id, upper);

  666.     const LadderRung *lower_rung = editor.findRung(logic_id, lower);

  667.     require(

  668.         upper_rung->cells[0].kind == LadderCellKind::Gap

  669.             && upper_rung->cells[1].kind == LadderCellKind::Gap

  670.             && !upper_rung->output.has_value()

  671.             && lower_rung->cells[0].kind == LadderCellKind::Gap

  672.             && lower_rung->cells[1].kind == LadderCellKind::Gap

  673.             && editor.findLogic(logic_id)->verticalConnections.empty(),

  674.         "drag deletion must clear cells, output, and vertical connection together");

  675.     require(editor.undo().succeeded,

  676.             "one undo must restore the complete drag deletion");

  677.     upper_rung = editor.findRung(logic_id, upper);

  678.     require(

  679.         upper_rung->cells[0].kind == LadderCellKind::Node

  680.             && upper_rung->cells[1].kind == LadderCellKind::Wire

  681.             && upper_rung->output.has_value()

  682.             && editor.findLogic(logic_id)->verticalConnections.size() == 1U,

  683.         "one undo must restore every object removed by the drag selection");

  684. }

  685. 

  686. void testCursorAdvanceAndInlineCommandInput()

  687. {

  688.     TestProjectStorage storage;

  689.     ProjectService project_service(storage);

  690.     LogicEditorService editor(project_service);

  691.     const std::string logic_id = editor.ensureDefaultLogic().id;

  692.     LogicEditorWidget widget(editor);

  693.     widget.setLogicId(logic_id);

  694.     widget.resize(1320, 440);

  695.     widget.show();

  696.     QCoreApplication::processEvents(QEventLoop::AllEvents);

  697. 

  698.     for (int column = 0;

  699.          column < ProjectLimits::kMaximumConditionColumns;

  700.          ++column)

  701.     {

  702.         require(widget.addHorizontalWire().succeeded,

  703.                 "repeated toolbar wire input must advance through all ten cells");

  704.     }

  705.     const ControlLogic *logic = editor.findLogic(logic_id);

  706.     require(logic != nullptr && logic->rungs.size() == 1U,

  707.             "the first wire on empty logic must atomically create one row");

  708.     for (const LadderCell &cell : logic->rungs.front().cells)

  709.     {

  710.         require(cell.kind == LadderCellKind::Wire,

  711.                 "ten repeated wire actions must fill ten distinct cells");

  712.     }

  713. 

  714.     require(widget.setOutput(

  715.                 CoilNodeConfig{

  716.                     RegisterAddress{RegisterArea::M, 60}, CoilMode::Normal},

  717.                 true).succeeded,

  718.             "the output action must succeed after the tenth cell");

  719.     logic = editor.findLogic(logic_id);

  720.     require(logic->rungs.size() == 2U

  721.                 && logic->rungs.front().output.has_value(),

  722.             "the output action must append the next empty row atomically");

  723.     require(widget.addHorizontalWire().succeeded

  724.                 && editor.findLogic(logic_id)->rungs[1].cells[0].kind

  725.                     == LadderCellKind::Wire,

  726.             "the toolbar cursor must continue at the appended row first cell");

  727. 

  728.     constexpr qreal left_bus = 60.0;

  729.     constexpr qreal cell_width = 96.0;

  730.     constexpr qreal output_width = 224.0;

  731.     constexpr qreal second_row_center = 197.0;

  732.     const auto double_click = [&widget](const QPointF &scene_point)

  733.     {

  734.         const QPoint point = widget.mapFromScene(scene_point);

  735.         QMouseEvent event(

  736.             QEvent::MouseButtonDblClick,

  737.             QPointF(point),

  738.             Qt::LeftButton,

  739.             Qt::LeftButton,

  740.             Qt::NoModifier);

  741.         QApplication::sendEvent(widget.viewport(), &event);

  742.         QCoreApplication::processEvents(QEventLoop::AllEvents);

  743.     };

  744.     const auto press_enter = [](QLineEdit *input)

  745.     {

  746.         QKeyEvent event(

  747.             QEvent::KeyPress,

  748.             Qt::Key_Return,

  749.             Qt::NoModifier);

  750.         QApplication::sendEvent(input, &event);

  751.         QCoreApplication::processEvents(QEventLoop::AllEvents);

  752.     };

  753. 

  754.     double_click(QPointF(

  755.         left_bus + 1.5 * cell_width,

  756.         second_row_center));

  757.     QLineEdit *input = widget.findChild<QLineEdit *>(

  758.         QStringLiteral("logicCommandInput"));

  759.     require(input != nullptr && input->isVisible()

  760.                 && input->completer() != nullptr,

  761.             "double-clicking a cell must open the inline command editor with completion");

  762.     const int first_input_left = input->geometry().left();

  763.     input->setText(QStringLiteral("LD M4"));

  764.     press_enter(input);

  765.     const LadderRung &second = editor.findLogic(logic_id)->rungs[1];

  766.     require(second.cells[1].node.has_value()

  767.                 && input->isVisible()

  768.                 && input->geometry().left() > first_input_left,

  769.             "a committed inline condition must move the editor one cell right");

  770. 

  771.     double_click(QPointF(

  772.         left_bus + ProjectLimits::kMaximumConditionColumns * cell_width

  773.             + output_width / 2.0,

  774.         second_row_center));

  775.     input->setText(QStringLiteral("OUT M61"));

  776.     press_enter(input);

  777.     logic = editor.findLogic(logic_id);

  778.     require(logic->rungs.size() == 3U

  779.                 && logic->rungs[1].output.has_value()

  780.                 && input->isVisible(),

  781.             "an inline output must append a row and keep continuous input active");

  782. }

  783. 

  784. void testSegmentLevelTraceProjection()

  785. {

  786.     TestProjectStorage storage;

  787.     ProjectService project_service(storage);

  788.     LogicEditorService editor(project_service);

  789.     const std::string logic_id = editor.ensureDefaultLogic().id;

  790.     const std::string upper = editor.addRung(logic_id).id;

  791.     const std::string lower = editor.addRung(logic_id).id;

  792.     const LogicEditorResult condition = editor.setConditionAtColumn(

  793.         logic_id,

  794.         upper,

  795.         0,

  796.         ContactNodeConfig{

  797.             RegisterAddress{RegisterArea::M, 0},

  798.             ContactMode::NormallyOpen},

  799.         true);

  800.     const LogicEditorResult output = editor.setOutput(

  801.         logic_id,

  802.         upper,

  803.         CoilNodeConfig{

  804.             RegisterAddress{RegisterArea::M, 10}, CoilMode::Normal},

  805.         true);

  806.     require(condition.succeeded && output.succeeded

  807.                 && editor.setVerticalConnection(

  808.                     logic_id, upper, lower, 0, true).succeeded,

  809.             "the segment trace fixture must create a contact, output and vertical edge");

  810.     const ControlLogic *logic = editor.findLogic(logic_id);

  811.     const std::string cell_id = logic->rungs.front().cells.front().id;

  812.     const std::string vertical_id = logic->verticalConnections.front().id;

  813. 

  814.     LogicTraceSnapshot trace;

  815.     LogicTraceValues &values = trace.logicValues[logic_id];

  816.     values.cellInputPowerValues[cell_id] = true;

  817.     values.cellPowerValues[cell_id] = false;

  818.     values.rungValues[upper] = false;

  819.     values.nodeValues[output.id] = false;

  820.     LogicEditorWidget widget(editor);

  821.     widget.setLogicId(logic_id);

  822.     widget.resize(1320, 360);

  823.     widget.show();

  824.     widget.setRuntimeTrace(trace);

  825.     QCoreApplication::processEvents(QEventLoop::AllEvents);

  826. 

  827.     bool found_split_contact = false;

  828.     bool found_inactive_output = false;

  829.     bool found_inactive_vertical = false;

  830.     for (QGraphicsItem *item : widget.scene()->items())

  831.     {

  832.         const QString type = item->data(0).toString();

  833.         if (type == QStringLiteral("cell")

  834.             && item->data(1).toString().toStdString() == upper

  835.             && item->data(2).toInt() == 0)

  836.         {

  837.             found_split_contact = item->data(6).toBool()

  838.                 && !item->data(7).toBool();

  839.         }

  840.         else if (type == QStringLiteral("output")

  841.                  && item->data(1).toString().toStdString() == upper)

  842.         {

  843.             found_inactive_output = !item->data(3).toBool()

  844.                 && !item->data(4).toBool();

  845.         }

  846.         else if (type == QStringLiteral("vertical")

  847.                  && item->data(1).toString().toStdString() == vertical_id)

  848.         {

  849.             found_inactive_vertical = !item->data(5).toBool();

  850.         }

  851.     }

  852.     require(found_split_contact && found_inactive_output

  853.                 && found_inactive_vertical,

  854.             "trace projection must keep left/right contact power and inactive verticals separate");

  855. 

  856.     values.cellPowerValues[cell_id] = true;

  857.     values.rungValues[upper] = true;

  858.     values.nodeValues[output.id] = true;

  859.     values.verticalConnectionValues[vertical_id] = true;

  860.     widget.setRuntimeTrace(trace);

  861.     bool found_active_output = false;

  862.     bool found_active_vertical = false;

  863.     for (QGraphicsItem *item : widget.scene()->items())

  864.     {

  865.         const QString type = item->data(0).toString();

  866.         if (type == QStringLiteral("output")

  867.             && item->data(1).toString().toStdString() == upper)

  868.         {

  869.             found_active_output = item->data(3).toBool()

  870.                 && item->data(4).toBool();

  871.         }

  872.         else if (type == QStringLiteral("vertical")

  873.                  && item->data(1).toString().toStdString() == vertical_id)

  874.         {

  875.             found_active_vertical = item->data(5).toBool();

  876.         }

  877.     }

  878.     require(found_active_output && found_active_vertical,

  879.         "explicitly energized output and vertical segments must project as active");

  880. }

  881. 

  882. void testLogicClipboardUsesExplicitObjectAndRowSelection()

  883. {

  884.     TestProjectStorage storage;

  885.     ProjectService project_service(storage);

  886.     LogicEditorService editor(project_service);

  887.     const std::string logic_id = editor.ensureDefaultLogic().id;

  888.     const std::string source = editor.addRung(logic_id).id;

  889.     const std::string target = editor.addRung(logic_id).id;

  890.     require(

  891.         editor.setHorizontalWireRange(

  892.             logic_id, source, 0, 0, true).succeeded,

  893.         "clipboard fixture must create one source wire");

  894.     editor.clearHistory();

  895. 

  896.     LogicEditorWidget widget(editor);

  897.     widget.setLogicId(logic_id);

  898.     widget.resize(1320, 360);

  899.     widget.show();

  900.     QCoreApplication::processEvents(QEventLoop::AllEvents);

  901.     const auto find_item = [&widget](

  902.         const QString &type,

  903.         const std::string &rung_id,

  904.         int column) -> QGraphicsItem *

  905.     {

  906.         const QList<QGraphicsItem *> items = widget.scene()->items();

  907.         const auto found = std::find_if(

  908.             items.cbegin(), items.cend(),

  909.             [&type, &rung_id, column](QGraphicsItem *item)

  910.             {

  911.                 return item->data(0).toString() == type

  912.                     && item->data(1).toString().toStdString() == rung_id

  913.                     && (column < 0 || item->data(2).toInt() == column);

  914.             });

  915.         return found == items.cend() ? nullptr : *found;

  916.     };

  917.     const auto click_item = [&widget](QGraphicsItem *item)

  918.     {

  919.         require(item != nullptr, "clipboard test target item must exist");

  920.         const QPoint point = widget.mapFromScene(

  921.             item->sceneBoundingRect().center());

  922.         QMouseEvent press(

  923.             QEvent::MouseButtonPress,

  924.             QPointF(point),

  925.             Qt::LeftButton,

  926.             Qt::LeftButton,

  927.             Qt::NoModifier);

  928.         QApplication::sendEvent(widget.viewport(), &press);

  929.         QMouseEvent release(

  930.             QEvent::MouseButtonRelease,

  931.             QPointF(point),

  932.             Qt::LeftButton,

  933.             Qt::NoButton,

  934.             Qt::NoModifier);

  935.         QApplication::sendEvent(widget.viewport(), &release);

  936.     };

  937. 

  938.     click_item(find_item(QStringLiteral("cell"), source, 0));

  939.     const LogicClipboardCopyResult wire_copy = widget.copySelection();

  940.     require(

  941.         widget.hasCopyableSelection()

  942.             && wire_copy.copy.succeeded

  943.             && wire_copy.fragment.mode == LogicClipboardMode::GridObjects

  944.             && wire_copy.fragment.cells.size() == 1U

  945.             && wire_copy.fragment.cells.front().kind == LadderCellKind::Wire

  946.             && wire_copy.fragment.rows.empty(),

  947.         "clicking one wire must copy one grid object instead of its whole row");

  948. 

  949.     click_item(find_item(QStringLiteral("cell"), target, 0));

  950.     const LogicClipboardPasteResult pasted = widget.pasteClipboard(

  951.         wire_copy.fragment);

  952.     require(

  953.         pasted.edit.succeeded

  954.             && editor.findLogic(logic_id)->rungs.size() == 2U

  955.             && editor.findCell(logic_id, target, 0)->kind

  956.                 == LadderCellKind::Wire,

  957.         "widget paste must place one wire without creating or copying a row");

  958.     const LogicClipboardCopyResult pasted_selection = widget.copySelection();

  959.     require(

  960.         pasted_selection.copy.succeeded

  961.             && pasted_selection.fragment.cells.size() == 1U

  962.             && pasted_selection.fragment.cells.front().kind

  963.                 == LadderCellKind::Wire,

  964.         "a successful paste must select the newly pasted wire");

  965. 

  966.     click_item(find_item(QStringLiteral("rowHeader"), source, -1));

  967.     const LogicClipboardCopyResult row_copy = widget.copySelection();

  968.     require(

  969.         row_copy.copy.succeeded

  970.             && row_copy.fragment.mode == LogicClipboardMode::WholeRows

  971.             && row_copy.fragment.rows.size() == 1U,

  972.         "only clicking the left row header may create a whole-row clipboard");

  973. }

  974. 

  975. } // namespace

  976. 

  977. int main(int argc, char *argv[])

  978. {

  979.     qputenv("QT_QPA_PLATFORM", QByteArrayLiteral("offscreen"));

  980.     QApplication application(argc, argv);

  981.     try

  982.     {

  983.         testAlarmConfigurationOffersMOnAndMOff();

  984.         testMonitorOffersAllNumericTypes();

  985.         testAlarmListKeepsFixedGeometryWhileRecordsChange();

  986.         testQueuedOfflineTraceIsIgnoredAfterReturningToEditing();

  987.         testLogicEditorGridSelectionAndDeletion();

  988.         testLadderLayoutAndDragDeletion();

  989.         testCursorAdvanceAndInlineCommandInput();

  990.         testSegmentLevelTraceProjection();

  991.         testLogicClipboardUsesExplicitObjectAndRowSelection();

  992.     }

  993.     catch (const std::exception &error)

  994.     {

  995.         std::cerr << "runtime panel controller tests failed: "

  996.                   << error.what() << '\n';

  997.         return 1;

  998.     }

  999. 

  1000.     std::cout << "runtime panel controller tests passed\n";

  1001.     return 0;

  1002. }