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.
152 Commits
1 Branch
183 MiB
 
 
 
 
Tree: 1a59ee8271
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '1a59ee8271'
${ noResults }
suyu_two/app/tests/hmi_editor_service_tests.cpp

774 lines
38 KiB
Raw Blame History 

  1. #include "domain/project_storage.h"

  2. #include "domain/register_repository.h"

  3. #include "domain/virtual_register_repository.h"

  4. #include "services/hmi_editor_service.h"

  5. #include "services/editor_history.h"

  6. #include "services/hmi_runtime_service.h"

  7. #include "services/hmi_navigation_service.h"

  8. #include "services/project_service.h"

  9. #include "support/test_support.h"

  10. 

  11. #include <exception>

  12. #include <iostream>

  13. #include <limits>

  14. #include <stdexcept>

  15. #include <string>

  16. #include <variant>

  17. 

  18. namespace {

  19. 

  20. using TestProjectStorage = TestSupport::InMemoryProjectStorage;

  21. using TestSupport::require;

  22. 

  23. void testControlEditing()

  24. {

  25.     // 覆盖控件创建、移动、绑定校验、重命名冲突和删除流程

  26.     TestProjectStorage storage;

  27.     ProjectService project_service(storage, defaultProjectLimitSettings());

  28.     HmiEditorService service(project_service, HmiDefaultSettings{});

  29.     const HmiEditorResult page_result = service.ensureDefaultPage();

  30.     require(page_result.succeeded, "default HMI page creation must succeed");

  31. 

  32.     const std::string page_id = page_result.id;

  33.     const HmiEditorResult button = service.addControl(page_id, HmiControlType::Button);

  34.     const HmiEditorResult indicator = service.addControl(page_id, HmiControlType::Indicator);

  35.     const HmiEditorResult display = service.addControl(

  36.         page_id, HmiControlType::NumericDisplay);

  37.     const HmiEditorResult input = service.addControl(page_id, HmiControlType::NumericInput);

  38.     require(button.succeeded && indicator.succeeded && display.succeeded

  39.                 && input.succeeded,

  40.             "basic HMI controls must be added");

  41. 

  42.     const HmiPage *page = service.findPage(page_id);

  43.     require(page != nullptr && page->controls.size() == 4,

  44.             "all added controls must be kept in the page model");

  45.     require(service.moveControl(page_id, button.id, {120, 80, 120, 40}).succeeded,

  46.             "a valid control move must succeed");

  47.     require(!service.moveControl(page_id, button.id, {790, 460, 120, 40}).succeeded,

  48.             "a move outside the page must be rejected");

  49. 

  50.     HmiControl updated = *service.findControl(page_id, button.id);

  51.     updated.binding = RegisterAddress{RegisterArea::D, 0};

  52.     require(!service.updateControl(page_id, button.id, updated).succeeded,

  53.             "buttons must reject D address bindings during editing");

  54.     updated.binding = RegisterAddress{RegisterArea::M, 7};

  55.     updated.text = "启动";

  56.     require(service.updateControl(page_id, button.id, updated).succeeded,

  57.             "a button M binding and edited text must be accepted");

  58. 

  59.     HmiControl duplicate = *service.findControl(page_id, indicator.id);

  60.     duplicate.id = button.id;

  61.     require(service.updateControl(page_id, indicator.id, duplicate).error

  62.                 == HmiEditorError::DuplicateId,

  63.             "duplicate control ids must be rejected");

  64. 

  65.     require(service.removeControl(page_id, indicator.id).succeeded,

  66.             "deleting a selected control must succeed");

  67.     require(service.findControl(page_id, indicator.id) == nullptr,

  68.             "deleted controls must not remain in the model");

  69. }

  70. 

  71. void testBatchControlAlignment()

  72. {

  73.     TestProjectStorage storage;

  74.     ProjectService project_service(storage, defaultProjectLimitSettings());

  75.     HmiEditorService service(project_service, HmiDefaultSettings{});

  76.     const std::string page_id = service.ensureDefaultPage().id;

  77.     const HmiEditorResult first = service.addControl(page_id, HmiControlType::Label);

  78.     const HmiEditorResult second = service.addControl(page_id, HmiControlType::Label);

  79.     const HmiEditorResult third = service.addControl(page_id, HmiControlType::Label);

  80.     require(first.succeeded && second.succeeded && third.succeeded,

  81.             "controls for alignment testing must be created");

  82. 

  83.     const std::vector<std::string> ids{first.id, second.id, third.id};

  84.     const std::vector<HmiRect> original_bounds{

  85.         {100, 80, 80, 30},

  86.         {240, 120, 100, 40},

  87.         {380, 160, 60, 20}};

  88.     for (std::size_t index = 0U; index < ids.size(); ++index)

  89.     {

  90.         HmiControl control = *service.findControl(page_id, ids[index]);

  91.         control.bounds = original_bounds[index];

  92.         require(service.updateControl(page_id, ids[index], control).succeeded,

  93.                 "alignment fixtures must be positioned successfully");

  94.     }

  95. 

  96.     service.clearHistory();

  97.     require(service.alignControls(page_id, ids, HmiAlignment::Left).succeeded,

  98.             "left alignment must succeed");

  99.     require(service.findControl(page_id, first.id)->bounds.x == 100

  100.                 && service.findControl(page_id, second.id)->bounds.x == 100

  101.                 && service.findControl(page_id, third.id)->bounds.x == 100,

  102.             "left alignment must use the selected group left edge");

  103.     require(service.findControl(page_id, second.id)->bounds.y == 120,

  104.             "alignment must preserve the non-aligned coordinate");

  105.     require(service.undo().succeeded

  106.                 && service.findControl(page_id, second.id)->bounds

  107.                        .x == original_bounds[1].x,

  108.             "alignment must be restored by one undo step");

  109.     require(service.redo().succeeded

  110.                 && service.findControl(page_id, third.id)->bounds.x == 100,

  111.             "alignment redo must restore the whole batch");

  112. 

  113.     const auto resetBounds = [&service, &page_id, &ids, &original_bounds]

  114.     {

  115.         for (std::size_t index = 0U; index < ids.size(); ++index)

  116.         {

  117.             HmiControl control = *service.findControl(page_id, ids[index]);

  118.             control.bounds = original_bounds[index];

  119.             require(service.updateControl(page_id, ids[index], control).succeeded,

  120.                     "alignment fixtures must be reset successfully");

  121.         }

  122.     };

  123.     const auto assertBounds = [&service, &page_id, &ids, &resetBounds](

  124.         HmiAlignment alignment, const std::vector<HmiRect> &expected,

  125.         const char *message)

  126.     {

  127.         resetBounds();

  128.         service.clearHistory();

  129.         require(service.alignControls(page_id, ids, alignment).succeeded, message);

  130.         for (std::size_t index = 0U; index < ids.size(); ++index)

  131.         {

  132.             const HmiControl *control = service.findControl(page_id, ids[index]);

  133.             require(control != nullptr

  134.                         && control->bounds.x == expected[index].x

  135.                         && control->bounds.y == expected[index].y,

  136.                     "alignment must calculate deterministic target coordinates");

  137.         }

  138.     };

  139. 

  140.     assertBounds(

  141.         HmiAlignment::HorizontalCenter,

  142.         {{230, 80, 0, 0}, {220, 120, 0, 0}, {240, 160, 0, 0}},

  143.         "horizontal center alignment must succeed");

  144.     assertBounds(

  145.         HmiAlignment::Right,

  146.         {{360, 80, 0, 0}, {340, 120, 0, 0}, {380, 160, 0, 0}},

  147.         "right alignment must succeed");

  148.     assertBounds(

  149.         HmiAlignment::Top,

  150.         {{100, 80, 0, 0}, {240, 80, 0, 0}, {380, 80, 0, 0}},

  151.         "top alignment must succeed");

  152.     assertBounds(

  153.         HmiAlignment::VerticalCenter,

  154.         {{100, 115, 0, 0}, {240, 110, 0, 0}, {380, 120, 0, 0}},

  155.         "vertical center alignment must succeed");

  156.     assertBounds(

  157.         HmiAlignment::Bottom,

  158.         {{100, 150, 0, 0}, {240, 140, 0, 0}, {380, 160, 0, 0}},

  159.         "bottom alignment must succeed");

  160. 

  161.     service.clearHistory();

  162.     const std::vector<HmiRect> before_invalid{

  163.         service.findControl(page_id, first.id)->bounds,

  164.         service.findControl(page_id, second.id)->bounds,

  165.         service.findControl(page_id, third.id)->bounds};

  166.     require(!service.alignControls(

  167.                 page_id, {first.id, "missing-control"}, HmiAlignment::Left)

  168.                  .succeeded,

  169.             "alignment must reject an unknown control before mutation");

  170.     require(!service.canUndo()

  171.                 && service.findControl(page_id, first.id)->bounds.x

  172.                        == before_invalid[0].x

  173.                 && service.findControl(page_id, second.id)->bounds.y

  174.                        == before_invalid[1].y,

  175.             "failed alignment must be atomic and leave history unchanged");

  176.     require(!service.alignControls(page_id, {first.id}, HmiAlignment::Left).succeeded,

  177.             "alignment must require at least two controls");

  178. 

  179.     HmiControl no_op = *service.findControl(page_id, first.id);

  180.     no_op.bounds.x = 100;

  181.     HmiControl no_op_second = *service.findControl(page_id, second.id);

  182.     no_op_second.bounds.x = 100;

  183.     HmiControl no_op_third = *service.findControl(page_id, third.id);

  184.     no_op_third.bounds.x = 100;

  185.     require(service.updateControl(page_id, first.id, no_op).succeeded

  186.                 && service.updateControl(page_id, second.id, no_op_second).succeeded

  187.                 && service.updateControl(page_id, third.id, no_op_third).succeeded,

  188.             "alignment no-op fixtures must be positioned successfully");

  189.     service.clearHistory();

  190.     require(service.alignControls(page_id, ids, HmiAlignment::Left).succeeded

  191.                 && !service.canUndo(),

  192.             "a no-op alignment must not create an undo step");

  193. }

  194. 

  195. void testRuntimeUsesRegisterRepository()

  196. {

  197.     // 运行服务只能经由仓库接口读写 M/D，不依赖具体离线实现

  198.     VirtualRegisterRepository repository;

  199.     HmiRuntimeService runtime_service(repository);

  200. 

  201.     HmiControl button;

  202.     button.id = "start";

  203.     button.type = HmiControlType::Button;

  204.     button.binding = RegisterAddress{RegisterArea::M, 12};

  205.     require(button.buttonOperation == HmiButtonOperation::MomentaryOn,

  206.             "new buttons must default to momentary ON");

  207.     require(runtime_service.operateButton(button, HmiButtonEvent::Pressed).succeeded,

  208.             "momentary button press must be accepted by the repository");

  209.     require(repository.readBit(*button.binding).value,

  210.             "momentary button press must write ON");

  211.     require(runtime_service.operateButton(button, HmiButtonEvent::Released).succeeded,

  212.             "momentary button release must be accepted by the repository");

  213.     require(!repository.readBit(*button.binding).value,

  214.             "momentary button release must write OFF");

  215. 

  216.     button.buttonOperation = HmiButtonOperation::SetOn;

  217.     require(runtime_service.operateButton(button, HmiButtonEvent::Pressed).succeeded,

  218.             "set ON button press must succeed");

  219.     require(repository.readBit(*button.binding).value,

  220.             "set ON button press must write ON");

  221.     require(runtime_service.operateButton(button, HmiButtonEvent::Released).succeeded,

  222.             "set ON button release must be ignored successfully");

  223.     require(repository.readBit(*button.binding).value,

  224.             "set ON button release must keep the bit ON");

  225. 

  226.     button.buttonOperation = HmiButtonOperation::SetOff;

  227.     require(runtime_service.operateButton(button, HmiButtonEvent::Pressed).succeeded,

  228.             "set OFF button press must succeed");

  229.     require(!repository.readBit(*button.binding).value,

  230.             "set OFF button press must write OFF");

  231. 

  232.     button.buttonOperation = HmiButtonOperation::Toggle;

  233.     require(runtime_service.operateButton(button, HmiButtonEvent::Pressed).succeeded,

  234.             "toggle button press must succeed");

  235.     require(repository.readBit(*button.binding).value,

  236.             "toggle button press must invert the current value");

  237. 

  238.     button.buttonOperation = HmiButtonOperation::MomentaryOn;

  239.     button.buttonEnableCondition = HmiButtonBitEnableCondition{

  240.         RegisterAddress{RegisterArea::M, 13}, true};

  241.     repository.writeBit({RegisterArea::M, 13}, false);

  242.     HmiButtonEnabledResult condition = runtime_service.evaluateButtonEnabled(button);

  243.     require(condition.succeeded && !condition.enabled

  244.                 && condition.error == HmiRuntimeError::ConditionNotMet,

  245.             "an M button condition must disable the button when it is false");

  246.     require(runtime_service.operateButton(button, HmiButtonEvent::Pressed).error

  247.                 == HmiRuntimeError::ConditionNotMet,

  248.             "a false M button condition must reject the write at the service boundary");

  249.     repository.writeBit({RegisterArea::M, 13}, true);

  250.     condition = runtime_service.evaluateButtonEnabled(button);

  251.     require(condition.succeeded && condition.enabled,

  252.             "an M button condition must enable the button when it is true");

  253.     require(runtime_service.operateButton(button, HmiButtonEvent::Pressed).succeeded

  254.                 && repository.readBit(*button.binding).value,

  255.             "a satisfied M button condition must allow the configured operation");

  256.     repository.writeBit({RegisterArea::M, 13}, false);

  257.     require(runtime_service.operateButton(button, HmiButtonEvent::Released).succeeded

  258.                 && !repository.readBit(*button.binding).value,

  259.             "a momentary button release must reset safely after its condition changes");

  260.     repository.writeBit({RegisterArea::M, 12}, true);

  261. 

  262.     HmiControl d_button = button;

  263.     d_button.buttonEnableCondition = HmiButtonWordEnableCondition{

  264.         RegisterAddress{RegisterArea::D, 100},

  265.         RegisterDataType::Int16,

  266.         HmiButtonConditionOperator::GreaterThanOrEqual,

  267.         50.0};

  268.     repository.writeWord({RegisterArea::D, 100}, 50);

  269.     condition = runtime_service.evaluateButtonEnabled(d_button);

  270.     require(condition.succeeded && condition.enabled,

  271.             "a satisfied D button condition must enable the button");

  272.     repository.writeWord({RegisterArea::D, 100}, 49);

  273.     condition = runtime_service.evaluateButtonEnabled(d_button);

  274.     require(condition.succeeded && !condition.enabled,

  275.             "a D button condition must compare the current repository value");

  276. 

  277.     HmiControl indicator;

  278.     indicator.id = "running";

  279.     indicator.type = HmiControlType::Indicator;

  280.     indicator.binding = RegisterAddress{RegisterArea::M, 12};

  281.     const HmiRuntimeReadResult indicator_value = runtime_service.readControl(indicator);

  282.     require(indicator_value.succeeded && indicator_value.bit_value,

  283.             "indicators must read M values through the repository");

  284. 

  285.     HmiControl numeric_input;

  286.     numeric_input.id = "target";

  287.     numeric_input.type = HmiControlType::NumericInput;

  288.     numeric_input.binding = RegisterAddress{RegisterArea::D, 9};

  289.     require(runtime_service.writeNumericInput(numeric_input, -18).succeeded,

  290.             "numeric input runtime writes must be accepted by the repository");

  291. 

  292.     HmiControl numeric_display;

  293.     numeric_display.id = "actual";

  294.     numeric_display.type = HmiControlType::NumericDisplay;

  295.     numeric_display.binding = RegisterAddress{RegisterArea::D, 9};

  296.     const HmiRuntimeReadResult numeric_value = runtime_service.readControl(numeric_display);

  297.     require(numeric_value.succeeded

  298.                 && std::get<std::int16_t>(numeric_value.numeric_value) == -18,

  299.             "numeric display must read D values through the repository");

  300. 

  301.     HmiControl float_input = numeric_input;

  302.     float_input.dataType = RegisterDataType::Float32;

  303.     float_input.binding = RegisterAddress{RegisterArea::D, 20};

  304.     require(runtime_service.writeNumericInput(float_input, -2.5).succeeded,

  305.             "Float32 numeric input must write two consecutive D words");

  306.     const HmiRuntimeReadResult float_value = runtime_service.readControl(float_input);

  307.     require(float_value.succeeded

  308.                 && std::get<float>(float_value.numeric_value) == -2.5f,

  309.             "Float32 numeric control must decode two consecutive D words");

  310.     require(!runtime_service.writeNumericInput(

  311.                 float_input, std::numeric_limits<double>::infinity()).succeeded,

  312.             "Float32 numeric input must reject infinity");

  313. 

  314.     HmiControl int32_input = numeric_input;

  315.     int32_input.dataType = RegisterDataType::Int32;

  316.     int32_input.binding = RegisterAddress{RegisterArea::D, 30};

  317.     require(runtime_service.writeNumericInput(int32_input, 305419896).succeeded,

  318.             "Int32 numeric input must write two consecutive D words");

  319.     const WordsReadResult int32_words = repository.readWords(*int32_input.binding, 2);

  320.     const HmiRuntimeReadResult int32_value = runtime_service.readControl(int32_input);

  321.     require(int32_words.succeeded

  322.                 && static_cast<std::uint16_t>(int32_words.values[0]) == 0x5678U

  323.                 && static_cast<std::uint16_t>(int32_words.values[1]) == 0x1234U

  324.                 && int32_value.succeeded

  325.                 && std::get<std::int32_t>(int32_value.numeric_value) == 0x12345678,

  326.             "Int32 HMI read/write must use low-word-first Xinje ordering");

  327. 

  328.     HmiControl double_input = numeric_input;

  329.     double_input.dataType = RegisterDataType::Float64;

  330.     double_input.binding = RegisterAddress{RegisterArea::D, 40};

  331.     require(runtime_service.writeNumericInput(double_input, 1.0).succeeded,

  332.             "Double numeric input must write four consecutive D words");

  333.     const WordsReadResult double_words = repository.readWords(*double_input.binding, 4);

  334.     const HmiRuntimeReadResult double_value = runtime_service.readControl(double_input);

  335.     require(double_words.succeeded

  336.                 && static_cast<std::uint16_t>(double_words.values[0]) == 0x0000U

  337.                 && static_cast<std::uint16_t>(double_words.values[1]) == 0x0000U

  338.                 && static_cast<std::uint16_t>(double_words.values[2]) == 0x0000U

  339.                 && static_cast<std::uint16_t>(double_words.values[3]) == 0x3ff0U

  340.                 && double_value.succeeded

  341.                 && std::get<double>(double_value.numeric_value) == 1.0,

  342.             "Double HMI read/write must use four low-address-first words");

  343.     require(!runtime_service.writeNumericInput(

  344.                 double_input, std::numeric_limits<double>::quiet_NaN()).succeeded,

  345.             "Double numeric input must reject NaN");

  346.     double_input.binding = RegisterAddress{RegisterArea::D, 3997};

  347.     require(runtime_service.writeNumericInput(double_input, 1.0).error

  348.                 == HmiRuntimeError::InvalidBinding,

  349.             "Double numeric input must reject odd or overflowing start addresses");

  350. 

  351. }

  352. 

  353. void testStatusTextRuntimeMapping()

  354. {

  355.     VirtualRegisterRepository repository;

  356.     HmiRuntimeService runtime(repository);

  357.     HmiControl status;

  358.     status.id = "machine-status";

  359.     status.type = HmiControlType::StatusText;

  360.     status.text = "Status";

  361.     status.binding = RegisterAddress{RegisterArea::M, 5};

  362.     status.statusText = HmiStatusBitTextConfig{"Stopped", "Running"};

  363. 

  364.     require(runtime.readStatusText(status).text == "Stopped",

  365.             "an OFF M bit must resolve to the configured OFF text");

  366.     repository.writeBit(*status.binding, true);

  367.     require(runtime.readStatusText(status).text == "Running",

  368.             "an ON M bit must resolve to the configured ON text");

  369.     require(runtime.writeNumericInput(status, 1).error

  370.                 == HmiRuntimeError::UnsupportedControl,

  371.             "status text must remain read-only");

  372. 

  373.     status.binding = RegisterAddress{RegisterArea::D, 20};

  374.     status.dataType = RegisterDataType::Float32;

  375.     status.statusText = HmiStatusWordTextConfig{{

  376.         {std::nullopt, 30.0, "Low"},

  377.         {30.0, 80.0, "Normal"},

  378.         {80.0, std::nullopt, "High"}}};

  379.     const auto write_float = [&repository, &status](float value)

  380.     {

  381.         const auto words = Float32Codec::encode(value);

  382.         repository.writeWords(*status.binding, {words[0], words[1]});

  383.     };

  384.     write_float(29.5f);

  385.     require(runtime.readStatusText(status).text == "Low",

  386.             "values below the first upper bound must resolve to the first text");

  387.     write_float(30.0f);

  388.     require(runtime.readStatusText(status).text == "Normal",

  389.             "a shared boundary must belong to the range starting at that boundary");

  390.     write_float(80.0f);

  391.     require(runtime.readStatusText(status).text == "High",

  392.             "the final boundary must belong to the unlimited upper range");

  393. 

  394.     repository.writeWords(

  395.         *status.binding,

  396.         {static_cast<std::int16_t>(0), static_cast<std::int16_t>(0x7fc0)});

  397.     require(!runtime.readStatusText(status).succeeded,

  398.             "NaN register bits must make status text unavailable");

  399. }

  400. 

  401. void testHistoryAndAtomicBatchDelete()

  402. {

  403.     TestProjectStorage storage;

  404.     ProjectService project_service(storage, defaultProjectLimitSettings());

  405.     HmiEditorService service(project_service, HmiDefaultSettings{});

  406.     const std::string page_id = service.ensureDefaultPage().id;

  407.     const HmiEditorResult first = service.addControl(page_id, HmiControlType::Label);

  408.     const HmiEditorResult second = service.addControl(page_id, HmiControlType::Label);

  409.     const HmiEditorResult third = service.addControl(page_id, HmiControlType::Label);

  410.     require(first.succeeded && second.succeeded && third.succeeded,

  411.             "controls for history testing must be created");

  412. 

  413.     service.clearHistory();

  414.     require(!service.removeControls(page_id, {first.id, "missing-control"}).succeeded,

  415.             "batch deletion must reject an unknown control before changing the page");

  416.     require(service.findPage(page_id)->controls.size() == 3U

  417.                 && !service.canUndo(),

  418.             "failed batch deletion must be atomic and leave history unchanged");

  419. 

  420.     require(service.removeControls(page_id, {first.id, second.id}).succeeded,

  421.             "batch deletion of valid controls must succeed");

  422.     require(service.findPage(page_id)->controls.size() == 1U

  423.                 && service.canUndo(),

  424.             "valid batch deletion must remove all selected controls in one history step");

  425.     require(service.undo().succeeded && service.findPage(page_id)->controls.size() == 3U,

  426.             "HMI undo must restore a deleted batch");

  427.     require(service.redo().succeeded && service.findPage(page_id)->controls.size() == 1U,

  428.             "HMI redo must reapply a deleted batch");

  429. 

  430.     service.clearHistory();

  431.     const HmiControl *remaining = service.findControl(page_id, third.id);

  432.     require(remaining != nullptr,

  433.             "the unselected control must survive a batch deletion");

  434.     require(service.moveControl(page_id, third.id, remaining->bounds).succeeded

  435.                 && !service.canUndo(),

  436.             "a no-op control move must not consume an undo step");

  437. 

  438.     service.clearHistory();

  439.     HmiControl candidate = *service.findControl(page_id, third.id);

  440.     for (int index = 1; index <= 101; ++index)

  441.     {

  442.         candidate.bounds.x = index;

  443.         require(service.updateControl(page_id, third.id, candidate).succeeded,

  444.                 "repeated valid HMI edits must succeed");

  445.     }

  446.     int undo_count = 0;

  447.     while (service.undo().succeeded)

  448.     {

  449.         ++undo_count;

  450.     }

  451.     require(undo_count == static_cast<int>(EditorHistory<int>::kMaximumEntries),

  452.             "HMI history must retain exactly the configured most recent steps");

  453. }

  454. 

  455. void testBatchPasteControls()

  456. {

  457.     TestProjectStorage storage;

  458.     ProjectService project_service(storage, defaultProjectLimitSettings());

  459.     HmiEditorService service(project_service, HmiDefaultSettings{});

  460.     const std::string page_id = service.ensureDefaultPage().id;

  461.     const HmiEditorResult first = service.addControl(

  462.         page_id, HmiControlType::NumericDisplay);

  463.     const HmiEditorResult second = service.addControl(page_id, HmiControlType::Label);

  464.     require(first.succeeded && second.succeeded,

  465.             "controls for paste testing must be created");

  466. 

  467.     HmiControl first_copy = *service.findControl(page_id, first.id);

  468.     HmiControl second_copy = *service.findControl(page_id, second.id);

  469.     first_copy.bounds = {100, 80, 80, 32};

  470.     first_copy.type = HmiControlType::NumericDisplay;

  471.     first_copy.text = "复制 Double";

  472.     first_copy.binding = RegisterAddress{RegisterArea::D, 100};

  473.     first_copy.dataType = RegisterDataType::Float64;

  474.     first_copy.properties[HmiAppearanceProperty::kTextColor] = "#E53935";

  475.     second_copy.bounds = {220, 80, 80, 32};

  476.     require(service.updateControl(page_id, first.id, first_copy).succeeded

  477.                 && service.updateControl(page_id, second.id, second_copy).succeeded,

  478.             "source controls must be movable before paste");

  479.     service.clearHistory();

  480. 

  481.     const HmiEditorResult pasted = service.pasteControls(

  482.         page_id, {first_copy, second_copy});

  483.     require(pasted.succeeded

  484.                 && service.findPage(page_id)->controls.size() == 4U

  485.                 && pasted.id != first.id && pasted.id != second.id,

  486.             "batch paste must create controls with fresh ids");

  487.     const HmiControl *pasted_control = service.findControl(page_id, pasted.id);

  488.     require(pasted_control != nullptr

  489.                 && pasted_control->bounds.x == first_copy.bounds.x + 20

  490.                 && pasted_control->bounds.y == first_copy.bounds.y + 20

  491.                 && pasted_control->text == first_copy.text

  492.                 && pasted_control->binding == first_copy.binding

  493.                 && pasted_control->dataType == RegisterDataType::Float64

  494.                 && pasted_control->properties == first_copy.properties,

  495.             "pasted controls must preserve data type, binding and appearance with an offset");

  496.     require(service.undo().succeeded

  497.                 && service.findPage(page_id)->controls.size() == 2U,

  498.             "batch control paste must be one undoable operation");

  499. }

  500. 

  501. void testRuntimeValidationAndPasteBoundaries()

  502. {

  503.     TestProjectStorage storage;

  504.     ProjectService project_service(storage, defaultProjectLimitSettings());

  505.     HmiEditorService editor(project_service, HmiDefaultSettings{});

  506.     const std::string page_id = editor.ensureDefaultPage().id;

  507. 

  508.     HmiControl label;

  509.     label.id = "label-source";

  510.     label.type = HmiControlType::Label;

  511.     label.bounds = {760, 360, 32, 32};

  512.     label.text = "边界";

  513.     require(editor.pasteControls(page_id, {label}, 20, 20).succeeded,

  514.             "a paste near the page edge must be clamped into the page");

  515.     const HmiPage *page = editor.findPage(page_id);

  516.     require(page != nullptr && page->controls.size() == 1U,

  517.             "edge paste must add exactly one control");

  518.     const HmiControl &edge_copy = page->controls.front();

  519.     require(edge_copy.bounds.x + edge_copy.bounds.width <= page->width

  520.                 && edge_copy.bounds.y + edge_copy.bounds.height <= page->height

  521.                 && edge_copy.bounds.x >= 0 && edge_copy.bounds.y >= 0,

  522.             "edge paste must keep the copied control inside page bounds");

  523. 

  524.     require(!editor.pasteControls(page_id, {}).succeeded,

  525.             "an empty HMI clipboard must be rejected");

  526.     HmiControl oversized = label;

  527.     oversized.bounds = {0, 0, page->width + 1, 32};

  528.     require(!editor.pasteControls(page_id, {oversized}).succeeded

  529.                 && editor.findPage(page_id)->controls.size() == 1U,

  530.             "a copied control wider than the target page must fail atomically");

  531.     HmiControl unsupported = label;

  532.     unsupported.type = HmiControlType::Count;

  533.     require(!editor.pasteControls(page_id, {unsupported}).succeeded

  534.                 && editor.findPage(page_id)->controls.size() == 1U,

  535.             "an unsupported copied HMI type must fail atomically");

  536. 

  537.     std::vector<HmiControl> too_many(513U, label);

  538.     require(!editor.pasteControls(page_id, too_many).succeeded

  539.                 && editor.findPage(page_id)->controls.size() == 1U,

  540.             "a paste batch above the page limit must be rejected before mutation");

  541. 

  542.     VirtualRegisterRepository repository;

  543.     HmiRuntimeService runtime(repository);

  544.     HmiControl unbound_indicator;

  545.     unbound_indicator.type = HmiControlType::Indicator;

  546.     require(runtime.readControl(unbound_indicator).error

  547.                 == HmiRuntimeError::MissingBinding,

  548.             "an unbound runtime indicator must report MissingBinding");

  549.     HmiControl wrong_area_indicator = unbound_indicator;

  550.     wrong_area_indicator.binding = RegisterAddress{RegisterArea::D, 0};

  551.     require(runtime.readControl(wrong_area_indicator).error

  552.                 == HmiRuntimeError::InvalidBinding,

  553.             "an indicator bound to D must report InvalidBinding");

  554.     HmiControl invalid_indicator = unbound_indicator;

  555.     invalid_indicator.binding = RegisterAddress{RegisterArea::M, 4001};

  556.     require(runtime.readControl(invalid_indicator).error

  557.                 == HmiRuntimeError::InvalidBinding,

  558.             "an indicator with an out-of-range address must report InvalidBinding");

  559.     require(runtime.readControl(label).error

  560.                 == HmiRuntimeError::UnsupportedControl,

  561.             "a static label must not be treated as a register runtime control");

  562. 

  563.     HmiControl wrong_button = unbound_indicator;

  564.     wrong_button.type = HmiControlType::Button;

  565.     wrong_button.binding = RegisterAddress{RegisterArea::D, 0};

  566.     require(runtime.operateButton(wrong_button, HmiButtonEvent::Pressed).error

  567.                 == HmiRuntimeError::InvalidBinding,

  568.             "a button bound to D must reject runtime writes");

  569.     HmiControl wrong_numeric = unbound_indicator;

  570.     wrong_numeric.type = HmiControlType::NumericInput;

  571.     wrong_numeric.binding = RegisterAddress{RegisterArea::M, 0};

  572.     require(runtime.writeNumericInput(wrong_numeric, 1).error

  573.                 == HmiRuntimeError::InvalidBinding,

  574.             "a numeric input bound to M must reject runtime writes");

  575. }

  576. 

  577. void testAppearanceEditing()

  578. {

  579.     TestProjectStorage storage;

  580.     ProjectService project_service(storage, defaultProjectLimitSettings());

  581.     HmiEditorService service(project_service, HmiDefaultSettings{});

  582.     const std::string page_id = service.ensureDefaultPage().id;

  583.     const HmiEditorResult label = service.addControl(page_id, HmiControlType::Label);

  584.     require(label.succeeded, "a label must be available for appearance editing");

  585. 

  586.     HmiControl appearance = *service.findControl(page_id, label.id);

  587.     appearance.properties[HmiAppearanceProperty::kTextColor] = "#E53935";

  588.     appearance.properties[HmiAppearanceProperty::kFontSize] = "18";

  589.     appearance.properties[HmiAppearanceProperty::kFontBold] = "true";

  590.     appearance.properties[HmiAppearanceProperty::kFontItalic] = "false";

  591.     require(service.updateControl(page_id, label.id, appearance).succeeded,

  592.             "valid appearance properties must be applied atomically");

  593.     const HmiControl *updated = service.findControl(page_id, label.id);

  594.     require(updated != nullptr

  595.                 && updated->properties.at(HmiAppearanceProperty::kTextColor) == "#E53935"

  596.                 && updated->properties.at(HmiAppearanceProperty::kFontSize) == "18"

  597.                 && updated->properties.at(HmiAppearanceProperty::kFontBold) == "true",

  598.             "appearance properties must be stored on the HMI control");

  599. 

  600.     HmiControl invalid = *updated;

  601.     invalid.properties[HmiAppearanceProperty::kTextColor] = "invalid";

  602.     require(!service.updateControl(page_id, label.id, invalid).succeeded,

  603.             "invalid appearance properties must be rejected without a partial update");

  604.     require(service.findControl(page_id, label.id)->properties.at(

  605.                 HmiAppearanceProperty::kTextColor) == "#E53935",

  606.             "failed appearance updates must leave the old color intact");

  607. 

  608.     require(service.undo().succeeded,

  609.             "appearance updates must participate in HMI undo history");

  610.     require(service.findControl(page_id, label.id)->properties.empty(),

  611.             "undo must remove the applied appearance properties");

  612.     require(service.redo().succeeded

  613.                 && service.findControl(page_id, label.id)->properties.at(

  614.                     HmiAppearanceProperty::kFontSize) == "18",

  615.             "redo must restore the applied appearance properties");

  616. }

  617. 

  618. void testPageLifecycleAndNavigation()

  619. {

  620.     TestProjectStorage storage;

  621.     ProjectService project_service(storage, defaultProjectLimitSettings());

  622.     HmiEditorService service(project_service, HmiDefaultSettings{});

  623.     const std::string main_id = service.ensureDefaultPage().id;

  624.     require(project_service.project().initialHmiPageId == main_id,

  625.             "the first page must become the initial HMI page");

  626. 

  627.     const HmiEditorResult settings = service.addPage("Settings");

  628.     const HmiEditorResult maintenance = service.addPage("Maintenance");

  629.     require(settings.succeeded && maintenance.succeeded,

  630.             "multiple HMI pages must be creatable");

  631.     require(service.renamePage(settings.id, "Parameters").succeeded,

  632.             "an HMI page must be renamable by stable id");

  633.     require(service.renamePage(maintenance.id, "Parameters").error

  634.                 == HmiEditorError::DuplicateName,

  635.             "HMI page names must remain unique");

  636.     require(service.movePage(maintenance.id, -1).succeeded

  637.                 && project_service.project().hmiPages.at(1).id == maintenance.id,

  638.             "HMI page order must be editable independently from page ids");

  639. 

  640.     const HmiEditorResult label = service.addControl(main_id, HmiControlType::Label);

  641.     require(label.succeeded

  642.                 && service.findControl(main_id, label.id)->isConfigured(),

  643.             "the editor service must expose a configured static Label control");

  644.     const HmiEditorResult alarm_list = service.addControl(

  645.         main_id, HmiControlType::AlarmList);

  646.     require(alarm_list.succeeded

  647.                 && service.findControl(main_id, alarm_list.id)->isConfigured()

  648.                 && !service.findControl(main_id, alarm_list.id)->binding.has_value(),

  649.             "AlarmList must be configured without a register binding");

  650.     HmiControl bound_alarm_list = *service.findControl(main_id, alarm_list.id);

  651.     bound_alarm_list.binding = RegisterAddress{RegisterArea::M, 20};

  652.     require(!service.updateControl(

  653.                 main_id, alarm_list.id, bound_alarm_list).succeeded,

  654.             "AlarmList must reject direct register bindings");

  655.     const HmiEditorResult jump = service.addControl(main_id, HmiControlType::PageJump);

  656.     require(jump.succeeded, "the editor service must expose PageJump creation");

  657.     HmiControl jump_control = *service.findControl(main_id, jump.id);

  658.     jump_control.pageJump = HmiPageJumpConfig{maintenance.id};

  659.     require(service.updateControl(main_id, jump.id, jump_control).succeeded,

  660.             "PageJump target updates must resolve stable page ids");

  661.     require(service.removePage(maintenance.id).error == HmiEditorError::PageReferenced,

  662.             "a page referenced by PageJump must not be deletable");

  663. 

  664.     require(service.setInitialPage(settings.id).succeeded,

  665.             "the user must be able to select a different initial page");

  666.     require(service.removePage(settings.id).error

  667.                 == HmiEditorError::InitialPageCannotBeRemoved,

  668.             "the initial page must not be deleted implicitly");

  669. 

  670.     HmiNavigationService navigation(project_service);

  671.     const HmiNavigationResult start = navigation.start();

  672.     require(start.succeeded && start.pageId == settings.id,

  673.             "runtime navigation must start from the persisted initial page");

  674.     require(navigation.navigateTo(maintenance.id).succeeded

  675.                 && navigation.currentPageId() == maintenance.id,

  676.             "runtime navigation must switch to an existing page");

  677.     require(navigation.navigateTo("missing").error

  678.                 == HmiNavigationError::PageNotFound,

  679.             "runtime navigation must reject an unknown page id");

  680.     navigation.stop();

  681.     require(navigation.currentPageId().empty(),

  682.             "stopping runtime navigation must clear session state");

  683. }

  684. 

  685. void testPageResizeIsAtomicAndUndoable()

  686. {

  687.     TestProjectStorage storage;

  688.     ProjectService project_service(storage, defaultProjectLimitSettings());

  689.     HmiEditorService service(project_service, HmiDefaultSettings{});

  690.     const std::string page_id = service.ensureDefaultPage().id;

  691.     const HmiEditorResult label = service.addControl(page_id, HmiControlType::Label);

  692.     require(label.succeeded, "page resize fixture must add a control");

  693. 

  694.     HmiControl control = *service.findControl(page_id, label.id);

  695.     control.bounds = {700, 340, 80, 32};

  696.     require(service.updateControl(page_id, label.id, control).succeeded,

  697.             "page resize fixture must place the control near the page edge");

  698.     require(service.resizePage(page_id, 1024, 600).succeeded,

  699.             "an HMI page must be resizable to a larger valid rectangle");

  700.     require(service.findPage(page_id)->width == 1024

  701.                 && service.findPage(page_id)->height == 600,

  702.             "page resize must update both dimensions");

  703.     require(service.resizePage(page_id, 700, 300).error

  704.                 == HmiEditorError::InvalidPage,

  705.             "page resize must reject dimensions that clip an existing control");

  706.     require(service.findPage(page_id)->width == 1024

  707.                 && service.findPage(page_id)->height == 600,

  708.             "a rejected page resize must leave the original dimensions intact");

  709.     require(service.undo().succeeded

  710.                 && service.findPage(page_id)->width == 800

  711.                 && service.findPage(page_id)->height == 400,

  712.             "page resize must participate in HMI undo history");

  713.     require(service.redo().succeeded

  714.                 && service.findPage(page_id)->width == 1024

  715.                 && service.findPage(page_id)->height == 600,

  716.             "page resize redo must restore the new dimensions");

  717.     require(service.resizePage(page_id, 319, 600).error

  718.                 == HmiEditorError::InvalidPage,

  719.             "page width below the business minimum must be rejected");

  720. }

  721. 

  722. void testConfiguredPageDefaultsAndLimits()

  723. {

  724.     TestProjectStorage storage;

  725.     ProjectLimitSettings limits;

  726.     limits.maximumHmiPages = 1U;

  727.     limits.maximumHmiControlsPerPage = 1U;

  728.     HmiDefaultSettings defaults;

  729.     defaults.pageWidth = 1024;

  730.     defaults.pageHeight = 600;

  731.     ProjectService project_service(storage, limits);

  732.     HmiEditorService service(project_service, defaults);

  733. 

  734.     const HmiEditorResult page = service.ensureDefaultPage();

  735.     require(page.succeeded

  736.                 && service.findPage(page.id)->width == 1024

  737.                 && service.findPage(page.id)->height == 600,

  738.             "configured HMI dimensions must initialize the default page");

  739.     require(!service.addPage("Second page").succeeded,

  740.             "the HMI editor must use the configured page limit");

  741.     require(service.addControl(page.id, HmiControlType::Label).succeeded

  742.                 && !service.addControl(page.id, HmiControlType::Label).succeeded,

  743.             "the HMI editor must use the configured per-page control limit");

  744. }

  745. 

  746. } // namespace

  747. 

  748. int main()

  749. {

  750.     try

  751.     {

  752.         // 编辑和运行场景分别验证服务层两条独立职责

  753.         testControlEditing();

  754.         testBatchControlAlignment();

  755.         testHistoryAndAtomicBatchDelete();

  756.         testBatchPasteControls();

  757.         testRuntimeValidationAndPasteBoundaries();

  758.         testAppearanceEditing();

  759.         testRuntimeUsesRegisterRepository();

  760.         testStatusTextRuntimeMapping();

  761.         testPageLifecycleAndNavigation();

  762.         testPageResizeIsAtomicAndUndoable();

  763.         testConfiguredPageDefaultsAndLimits();

  764.     }

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

  766.     {

  767.         std::cerr << "HMI editor service tests failed: " << error.what() << '\n';

  768.         return 1;

  769.     }

  770. 

  771.     std::cout << "HMI editor service tests passed\n";

  772.     return 0;

  773. }