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

565 lines
22 KiB
Raw Blame History 

  1. #include "services/runtime_mode_service.h"

  2. #include "services/logic_editor_service.h"

  3. #include "services/offline_simulation_service.h"

  4. #include "services/project_service.h"

  5. #include "domain/active_register_repository.h"

  6. #include "domain/project_storage.h"

  7. #include "domain/register_repository.h"

  8. #include "domain/virtual_register_repository.h"

  9. #include "infrastructure/plc_register_repository.h"

  10. #include "support/test_support.h"

  11. 

  12. #include <functional>

  13. #include <iostream>

  14. #include <stdexcept>

  15. #include <string>

  16. #include <utility>

  17. 

  18. namespace {

  19. 

  20. using TestProjectStorage = TestSupport::InMemoryProjectStorage;

  21. 

  22. class ReadyPlcGateway final : public PlcCommunicationGateway

  23. {

  24. public:

  25.     PlcCommunicationResult connectDevice(const PlcSerialConfiguration &) override

  26.     {

  27.         connection_state = PlcConnectionState::Connected;

  28.         if (state_changed)

  29.         {

  30.             state_changed();

  31.         }

  32.         return {true, {}};

  33.     }

  34. 

  35.     void disconnectDevice() override

  36.     {

  37.         connection_state = PlcConnectionState::Disconnected;

  38.         initial_read = false;

  39.     }

  40. 

  41.     PlcCommunicationResult setPollAddresses(

  42.         const std::vector<RegisterAddress> &addresses) override

  43.     {

  44.         return setPollAddresses(addresses, {});

  45.     }

  46. 

  47.     PlcCommunicationResult setPollAddresses(

  48.         const std::vector<RegisterAddress> &addresses,

  49.         const std::vector<RegisterWordRange> &ranges) override

  50.     {

  51.         if (reject_poll_configuration)

  52.         {

  53.             return {false, "poll configuration rejected"};

  54.         }

  55.         poll_addresses = addresses;

  56.         poll_ranges = ranges;

  57.         return {true, {}};

  58.     }

  59.     PlcConnectionState state() const override { return connection_state; }

  60.     bool initialReadCompleted() const override { return initial_read; }

  61.     PlcCommunicationError lastErrorType() const override

  62.     {

  63.         return PlcCommunicationError::None;

  64.     }

  65.     const std::string &lastError() const override { return last_error; }

  66. 

  67.     void setCallbacks(

  68.         std::function<void()> state_callback,

  69.         std::function<void(bool)> initial_callback,

  70.         std::function<void()> cache_callback,

  71.         std::function<void()> poll_cycle_callback,

  72.         std::function<void(const std::string &)> error_callback) override

  73.     {

  74.         state_changed = std::move(state_callback);

  75.         initial_read_changed = std::move(initial_callback);

  76.         cache_updated = std::move(cache_callback);

  77.         poll_cycle_completed = std::move(poll_cycle_callback);

  78.         error_reported = std::move(error_callback);

  79.     }

  80. 

  81.     void completeInitialRead()

  82.     {

  83.         initial_read = true;

  84.         if (initial_read_changed)

  85.         {

  86.             initial_read_changed(true);

  87.         }

  88.     }

  89. 

  90.     void completePollCycle()

  91.     {

  92.         if (poll_cycle_completed)

  93.         {

  94.             poll_cycle_completed();

  95.         }

  96.     }

  97. 

  98.     void reportFault()

  99.     {

  100.         connection_state = PlcConnectionState::Faulted;

  101.         initial_read = false;

  102.         if (state_changed)

  103.         {

  104.             state_changed();

  105.         }

  106.     }

  107. 

  108.     const std::vector<RegisterAddress> &pollAddresses() const

  109.     {

  110.         return poll_addresses;

  111.     }

  112. 

  113.     const std::vector<RegisterWordRange> &pollRanges() const

  114.     {

  115.         return poll_ranges;

  116.     }

  117. 

  118.     bool reject_poll_configuration = false;

  119. 

  120. private:

  121.     PlcConnectionState connection_state = PlcConnectionState::Disconnected;

  122.     bool initial_read = false;

  123.     std::string last_error;

  124.     std::function<void()> state_changed;

  125.     std::function<void(bool)> initial_read_changed;

  126.     std::function<void()> cache_updated;

  127.     std::function<void()> poll_cycle_completed;

  128.     std::function<void(const std::string &)> error_reported;

  129.     std::vector<RegisterAddress> poll_addresses;

  130.     std::vector<RegisterWordRange> poll_ranges;

  131. };

  132. 

  133. using TestSupport::require;

  134. 

  135. void setConditionPath(LadderRung *rung, LogicNode node)

  136. {

  137.     for (int column = 0;

  138.          column < ProjectLimits::kMaximumConditionColumns;

  139.          ++column)

  140.     {

  141.         rung->cells.push_back({

  142.             rung->id + "-cell-" + std::to_string(column),

  143.             column == 0 ? LadderCellKind::Node : LadderCellKind::Wire,

  144.             column == 0 ? std::optional<LogicNode>{node} : std::nullopt});

  145.     }

  146. }

  147. 

  148. void testModeTransitions()

  149. {

  150.     // 验证服务将 PLC 首读状态与领域模式切换规则正确组合

  151.     TestProjectStorage storage;

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

  153.     VirtualRegisterRepository virtual_repository;

  154.     VirtualRegisterRepository plc_repository;

  155.     ActiveRegisterRepository active_repository(virtual_repository);

  156.     OfflineSimulationService simulation_service(virtual_repository);

  157.     OnlineLogicMonitorService online_monitor_service(plc_repository);

  158.     LogicEditorService logic_editor_service(project_service);

  159.     ReadyPlcGateway gateway;

  160.     RuntimeModeService service(

  161.         project_service,

  162.         logic_editor_service,

  163.         simulation_service,

  164.         online_monitor_service);

  165.     service.configurePlc(

  166.         gateway, active_repository, virtual_repository, plc_repository);

  167. 

  168.     Project &project = project_service.editProject();

  169.     HmiPage page;

  170.     page.id = "runtime-page";

  171.     page.name = "Runtime";

  172.     HmiControl int32_display;

  173.     int32_display.id = "runtime-int32";

  174.     int32_display.type = HmiControlType::NumericDisplay;

  175.     int32_display.bounds = {0, 0, 100, 40};

  176.     int32_display.binding = RegisterAddress{RegisterArea::D, 50};

  177.     int32_display.dataType = RegisterDataType::Int32;

  178.     page.controls.push_back(int32_display);

  179.     HmiControl double_display = int32_display;

  180.     double_display.id = "runtime-double";

  181.     double_display.bounds = {120, 0, 100, 40};

  182.     double_display.binding = RegisterAddress{RegisterArea::D, 60};

  183.     double_display.dataType = RegisterDataType::Float64;

  184.     page.controls.push_back(double_display);

  185.     HmiControl double_status = int32_display;

  186.     double_status.id = "runtime-double-status";

  187.     double_status.type = HmiControlType::StatusText;

  188.     double_status.bounds = {240, 0, 140, 40};

  189.     double_status.binding = RegisterAddress{RegisterArea::D, 70};

  190.     double_status.dataType = RegisterDataType::Float64;

  191.     double_status.statusText = HmiStatusWordTextConfig{{

  192.         {std::nullopt, 0.0, "Low"},

  193.         {0.0, std::nullopt, "High"}}};

  194.     page.controls.push_back(double_status);

  195.     HmiControl gated_button;

  196.     gated_button.id = "runtime-gated-button";

  197.     gated_button.type = HmiControlType::Button;

  198.     gated_button.bounds = {400, 0, 120, 40};

  199.     gated_button.binding = RegisterAddress{RegisterArea::M, 30};

  200.     gated_button.buttonEnableCondition = HmiButtonWordEnableCondition{

  201.         RegisterAddress{RegisterArea::D, 80},

  202.         RegisterDataType::Int32,

  203.         HmiButtonConditionOperator::GreaterThanOrEqual,

  204.         1.0};

  205.     page.controls.push_back(gated_button);

  206.     project.initialHmiPageId = page.id;

  207.     project.hmiPages.push_back(page);

  208.     project.alarmDefinitions.push_back(

  209.         {"alarm-m", {RegisterArea::M, 12}, AlarmCondition::MOn, 0, "M alarm"});

  210.     project.alarmDefinitions.push_back(

  211.         {"alarm-d", {RegisterArea::D, 34}, AlarmCondition::DHigh, 100, "D alarm"});

  212.     project.registerComments = {

  213.         {RegisterAddress{RegisterArea::M, 3999}, "只用于说明"},

  214.         {RegisterAddress{RegisterArea::D, 3999}, "只用于说明"}};

  215. 

  216.     ControlLogic logic;

  217.     logic.id = "poll-logic";

  218.     logic.name = "Poll logic";

  219.     LogicNode edge;

  220.     edge.id = "poll-edge";

  221.     edge.config = EdgeContactNodeConfig{

  222.         RegisterAddress{RegisterArea::M, 20}, EdgeMode::Rising};

  223.     LogicNode edge_coil;

  224.     edge_coil.id = "poll-edge-coil";

  225.     edge_coil.config = CoilNodeConfig{

  226.         RegisterAddress{RegisterArea::M, 21}, CoilMode::Normal};

  227.     LadderRung edge_rung;

  228.     edge_rung.id = "poll-edge-rung";

  229.     edge_rung.name = "Poll edge";

  230.     setConditionPath(&edge_rung, edge);

  231.     edge_rung.output = edge_coil;

  232.     logic.rungs.push_back(edge_rung);

  233.     LogicNode comparison;

  234.     comparison.id = "poll-comparison";

  235.     comparison.config = CompareNodeConfig{

  236.         RegisterAddress{RegisterArea::D, 35}, ComparisonOperator::GreaterThan, 0};

  237.     LogicNode comparison_coil;

  238.     comparison_coil.id = "poll-comparison-coil";

  239.     comparison_coil.config = CoilNodeConfig{

  240.         RegisterAddress{RegisterArea::M, 22}, CoilMode::Normal};

  241.     LadderRung comparison_rung;

  242.     comparison_rung.id = "poll-comparison-rung";

  243.     comparison_rung.name = "Poll comparison";

  244.     setConditionPath(&comparison_rung, comparison);

  245.     comparison_rung.output = comparison_coil;

  246.     logic.rungs.push_back(comparison_rung);

  247.     LogicNode move_input;

  248.     move_input.id = "poll-move-input";

  249.     move_input.config = ContactNodeConfig{

  250.         RegisterAddress{RegisterArea::M, 27}, ContactMode::NormallyOpen};

  251.     LogicNode move_output;

  252.     move_output.id = "poll-move";

  253.     move_output.config = MoveNodeConfig{

  254.         WordOperand{

  255.             WordOperandKind::Register,

  256.             RegisterAddress{RegisterArea::D, 38},

  257.             0},

  258.         RegisterAddress{RegisterArea::D, 39}};

  259.     LadderRung move_rung;

  260.     move_rung.id = "poll-move-rung";

  261.     move_rung.name = "Poll MOVE";

  262.     setConditionPath(&move_rung, move_input);

  263.     move_rung.output = move_output;

  264.     logic.rungs.push_back(move_rung);

  265.     LogicNode add_input;

  266.     add_input.id = "poll-add-input";

  267.     add_input.config = ContactNodeConfig{

  268.         RegisterAddress{RegisterArea::M, 28}, ContactMode::NormallyOpen};

  269.     LogicNode add_output;

  270.     add_output.id = "poll-add";

  271.     add_output.config = ArithmeticNodeConfig{

  272.         ArithmeticOperation::Add,

  273.         WordOperand{

  274.             WordOperandKind::Register,

  275.             RegisterAddress{RegisterArea::D, 40},

  276.             0},

  277.         WordOperand{

  278.             WordOperandKind::Constant,

  279.             RegisterAddress{RegisterArea::D, 0},

  280.             1},

  281.         RegisterAddress{RegisterArea::D, 41}};

  282.     LadderRung add_rung;

  283.     add_rung.id = "poll-add-rung";

  284.     add_rung.name = "Poll ADD";

  285.     setConditionPath(&add_rung, add_input);

  286.     add_rung.output = add_output;

  287.     logic.rungs.push_back(add_rung);

  288.     project.controlLogics.push_back(logic);

  289. 

  290.     require(service.mode() == ApplicationMode::Editing,

  291.             "service must start in editing mode");

  292.     require(service.policy().allowsProjectEditing,

  293.             "editing mode must allow project editing");

  294. 

  295.     require(service.enterOfflineRunning().succeeded,

  296.             "editing mode must enter offline running");

  297.     require(service.simulationState() == SimulationState::Running,

  298.             "offline mode must start the software executor");

  299.     require(service.policy().usesVirtualRegisters,

  300.             "offline running must use virtual registers");

  301.     require(service.enterOnlineRunning().error

  302.                 == ModeTransitionError::MustReturnToEditing,

  303.             "running modes must not switch directly");

  304. 

  305.     require(service.enterEditing().succeeded,

  306.             "offline running must return to editing");

  307.     require(service.simulationState() == SimulationState::Stopped,

  308.             "returning to editing must stop the software executor first");

  309.     require(service.enterOnlineRunning().error

  310.                 == ModeTransitionError::InitialPlcReadRequired,

  311.             "online running must require an initial PLC read");

  312. 

  313.     require(service.connectPlc(

  314.                 {"COM9", 1, 9600, 8, 2, 1, 1000, 2, 200}).succeeded,

  315.             "PLC connection must be established before its initial read can complete");

  316.     require(gateway.pollAddresses()

  317.                 == std::vector<RegisterAddress>({

  318.                     {RegisterArea::M, 12}, {RegisterArea::M, 20},

  319.                     {RegisterArea::M, 21}, {RegisterArea::M, 22},

  320.                     {RegisterArea::M, 27}, {RegisterArea::M, 28},

  321.                     {RegisterArea::M, 30},

  322.                     {RegisterArea::D, 34}, {RegisterArea::D, 35},

  323.                     {RegisterArea::D, 38}, {RegisterArea::D, 39},

  324.                     {RegisterArea::D, 40}, {RegisterArea::D, 41},

  325.                     {RegisterArea::D, 50}, {RegisterArea::D, 51},

  326.                     {RegisterArea::D, 60}, {RegisterArea::D, 61},

  327.                     {RegisterArea::D, 62}, {RegisterArea::D, 63},

  328.                     {RegisterArea::D, 70}, {RegisterArea::D, 71},

  329.                     {RegisterArea::D, 72}, {RegisterArea::D, 73},

  330.                     {RegisterArea::D, 80}, {RegisterArea::D, 81}})

  331.                 && gateway.pollRanges()

  332.                     == std::vector<RegisterWordRange>({

  333.                         {{RegisterArea::D, 50}, 2},

  334.                         {{RegisterArea::D, 60}, 4},

  335.                         {{RegisterArea::D, 70}, 4},

  336.                         {{RegisterArea::D, 80}, 2}}),

  337.             "instructions and multi-word status text must be fully polled while comments stay metadata-only");

  338.     gateway.completeInitialRead();

  339.     require(service.initialPlcReadCompleted(),

  340.             "service must retain the initial PLC read state");

  341.     plc_repository.writeBit({RegisterArea::M, 20}, true);

  342.     require(service.enterOnlineRunning().succeeded,

  343.             "online running must start after an initial PLC read");

  344.     require(service.simulationState() == SimulationState::Stopped,

  345.             "online running must keep the offline executor stopped");

  346.     require(service.onlineLogicMonitorService().state()

  347.                 == OnlineLogicMonitorState::Running,

  348.             "online running must start the local read-only trace executor");

  349.     require(!plc_repository.readBit({RegisterArea::M, 21}).value,

  350.             "the local trace output must not change the PLC source repository");

  351.     require(service.policy().usesPlcRegisters,

  352.             "online running must use PLC registers");

  353.     require(service.policy().runsLogicExecutor,

  354.             "online running must advertise the local read-only trace executor");

  355.     const std::uint64_t scan_count = service.onlineLogicMonitorService()

  356.         .successfulScanCount();

  357.     gateway.completePollCycle();

  358.     require(service.onlineLogicMonitorService().successfulScanCount()

  359.                 == scan_count + 1U,

  360.             "a completed PLC poll cycle must trigger one new local trace scan");

  361. }

  362. 

  363. void testHmiOnlyRuntimeSkipsLogicExecutor()

  364. {

  365.     TestProjectStorage storage;

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

  367.     VirtualRegisterRepository virtual_repository;

  368.     PlcRegisterRepository plc_repository;

  369.     ActiveRegisterRepository active_repository(virtual_repository);

  370.     OfflineSimulationService simulation_service(virtual_repository);

  371.     OnlineLogicMonitorService online_monitor_service(plc_repository);

  372.     LogicEditorService logic_editor_service(project_service);

  373.     ReadyPlcGateway gateway;

  374.     RuntimeModeService service(

  375.         project_service,

  376.         logic_editor_service,

  377.         simulation_service,

  378.         online_monitor_service);

  379.     service.configurePlc(

  380.         gateway, active_repository, virtual_repository, plc_repository);

  381.     service.setHmiOnlyRuntime(true);

  382.     require(!active_repository.readBit({RegisterArea::M, 0}).succeeded,

  383.             "HMI-only runtime must use the unavailable PLC cache before its first read");

  384. 

  385.     HmiPage page;

  386.     page.id = "hmi-only-page";

  387.     page.name = "HMI only";

  388.     HmiControl button;

  389.     button.id = "hmi-only-button";

  390.     button.type = HmiControlType::Button;

  391.     button.bounds = {0, 0, 100, 40};

  392.     button.binding = RegisterAddress{RegisterArea::M, 0};

  393.     page.controls.push_back(button);

  394.     Project &project = project_service.editProject();

  395.     project.hmiPages.push_back(page);

  396.     project.initialHmiPageId = page.id;

  397.     // 该逻辑故意不完整，HMI 专用导出不应受它阻断

  398.     project.controlLogics.push_back(ControlLogic{});

  399. 

  400.     require(service.connectPlc(

  401.                 {"COM9", 1, 9600, 8, 2, 1, 1000, 2, 200}).succeeded,

  402.             "HMI-only runtime must accept a PLC connection request");

  403.     gateway.completeInitialRead();

  404.     plc_repository.updateBit(0, false);

  405.     require(service.enterOnlineRunning().succeeded,

  406.             "HMI-only runtime must ignore ladder logic readiness");

  407.     require(service.policy().usesPlcRegisters

  408.                 && online_monitor_service.state()

  409.                     == OnlineLogicMonitorState::Stopped,

  410.             "HMI-only runtime must use PLC registers without starting local logic");

  411.     require(active_repository.readBit({RegisterArea::M, 0}).succeeded,

  412.             "HMI-only runtime must switch HMI reads to the PLC cache");

  413.     plc_repository.updateBit(0, true);

  414.     require(virtual_repository.writeBit({RegisterArea::M, 0}, false).succeeded

  415.                 && active_repository.readBit({RegisterArea::M, 0}).value,

  416.             "HMI-only runtime fault fixture must separate virtual and PLC values");

  417.     plc_repository.invalidate();

  418.     gateway.reportFault();

  419.     require(service.mode() == ApplicationMode::OnlineRunning

  420.                 && !service.initialPlcReadCompleted()

  421.                 && active_repository.readBit({RegisterArea::M, 0}).error

  422.                     == RegisterError::Unavailable,

  423.             "HMI-only runtime faults must keep the PLC cache active without falling back offline");

  424. }

  425. 

  426. void testMonitorPollRangeRollback()

  427. {

  428.     TestProjectStorage storage;

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

  430.     VirtualRegisterRepository virtual_repository;

  431.     VirtualRegisterRepository plc_repository;

  432.     ActiveRegisterRepository active_repository(virtual_repository);

  433.     OfflineSimulationService simulation_service(virtual_repository);

  434.     OnlineLogicMonitorService online_monitor_service(plc_repository);

  435.     LogicEditorService logic_editor_service(project_service);

  436.     ReadyPlcGateway gateway;

  437.     RuntimeModeService service(

  438.         project_service,

  439.         logic_editor_service,

  440.         simulation_service,

  441.         online_monitor_service);

  442.     service.configurePlc(

  443.         gateway, active_repository, virtual_repository, plc_repository);

  444. 

  445.     gateway.reject_poll_configuration = true;

  446.     const PlcCommunicationResult rejected = service.setMonitorAddresses(

  447.         {{RegisterArea::D, 100}, {RegisterArea::D, 101},

  448.          {RegisterArea::D, 102}, {RegisterArea::D, 103}},

  449.         {{{RegisterArea::D, 100}, 4}});

  450.     require(!rejected.succeeded,

  451.             "a gateway-rejected Double monitor range must fail atomically");

  452. 

  453.     gateway.reject_poll_configuration = false;

  454.     require(service.refreshPlcPollAddresses().succeeded

  455.                 && gateway.pollAddresses().empty()

  456.                 && gateway.pollRanges().empty(),

  457.             "a rejected monitor candidate must not remain in runtime poll state");

  458. }

  459. 

  460. void testDisconnectedOutputBlocksOfflineAndOnlineRuntime()

  461. {

  462.     TestProjectStorage storage;

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

  464.     VirtualRegisterRepository virtual_repository;

  465.     VirtualRegisterRepository plc_repository;

  466.     ActiveRegisterRepository active_repository(virtual_repository);

  467.     OfflineSimulationService simulation_service(virtual_repository);

  468.     OnlineLogicMonitorService online_monitor_service(plc_repository);

  469.     LogicEditorService logic_editor_service(project_service);

  470.     ReadyPlcGateway gateway;

  471.     RuntimeModeService service(

  472.         project_service,

  473.         logic_editor_service,

  474.         simulation_service,

  475.         online_monitor_service);

  476.     service.configurePlc(

  477.         gateway, active_repository, virtual_repository, plc_repository);

  478. 

  479.     ControlLogic logic;

  480.     logic.id = "broken-logic";

  481.     logic.name = "断路逻辑";

  482.     LadderRung rung;

  483.     rung.id = "broken-rung";

  484.     rung.name = "行 1";

  485.     for (int column = 0;

  486.          column < ProjectLimits::kMaximumConditionColumns;

  487.          ++column)

  488.     {

  489.         rung.cells.push_back({

  490.             "broken-cell-" + std::to_string(column),

  491.             LadderCellKind::Gap,

  492.             std::nullopt});

  493.     }

  494.     rung.output = LogicNode{

  495.         "broken-output",

  496.         CoilNodeConfig{

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

  498.         true};

  499.     logic.rungs.push_back(rung);

  500.     LadderRung unused;

  501.     unused.id = "unused-rung";

  502.     unused.name = "行 2";

  503.     for (int column = 0;

  504.          column < ProjectLimits::kMaximumConditionColumns;

  505.          ++column)

  506.     {

  507.         unused.cells.push_back({

  508.             "unused-cell-" + std::to_string(column),

  509.             column >= 3 && column <= 5

  510.                 ? LadderCellKind::Wire : LadderCellKind::Gap,

  511.             std::nullopt});

  512.     }

  513.     logic.rungs.push_back(unused);

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

  515.     logic_editor_service.clearHistory();

  516. 

  517.     const ModeTransitionResult offline = service.enterOfflineRunning();

  518.     require(

  519.         !offline.succeeded

  520.             && offline.error == ModeTransitionError::ProjectNotReady

  521.             && offline.detail.find("断路逻辑") != std::string::npos

  522.             && offline.detail.find("第 11 列") != std::string::npos

  523.             && offline.detail.find("第 1 列") != std::string::npos

  524.             && service.mode() == ApplicationMode::Editing

  525.             && simulation_service.state() == SimulationState::Stopped

  526.             && service.lastSyntaxCheck().changed

  527.             && service.lastSyntaxCheck().removedWireCells == 3U

  528.             && logic_editor_service.findCell(

  529.                 "broken-logic", "unused-rung", 3)->kind

  530.                 == LadderCellKind::Gap

  531.             && logic_editor_service.canUndo(),

  532.         "runtime preflight must normalize unused lines before rejecting a broken output");

  533. 

  534.     require(service.connectPlc(

  535.                 {"COM9", 1, 9600, 8, 2, 1, 1000, 2, 200}).succeeded,

  536.             "the online connectivity check requires a ready PLC cache");

  537.     gateway.completeInitialRead();

  538.     const ModeTransitionResult online = service.enterOnlineRunning();

  539.     require(

  540.         !online.succeeded

  541.             && online.error == ModeTransitionError::ProjectNotReady

  542.             && online.detail == offline.detail

  543.             && service.mode() == ApplicationMode::Editing

  544.             && online_monitor_service.state()

  545.                 == OnlineLogicMonitorState::Stopped

  546.             && !service.lastSyntaxCheck().changed

  547.             && logic_editor_service.undo().succeeded

  548.             && logic_editor_service.findCell(

  549.                 "broken-logic", "unused-rung", 3)->kind

  550.                 == LadderCellKind::Wire,

  551.         "the same disconnected output validation must block online runtime");

  552. }

  553. 

  554. } // namespace

  555. 

  556. int main()

  557. {

  558.     return TestSupport::runTestSuite("runtime mode service tests", {

  559.         {"testModeTransitions", testModeTransitions},

  560.         {"testHmiOnlyRuntimeSkipsLogicExecutor", testHmiOnlyRuntimeSkipsLogicExecutor},

  561.         {"testMonitorPollRangeRollback", testMonitorPollRangeRollback},

  562.         {"testDisconnectedOutputBlocksOfflineAndOnlineRuntime", testDisconnectedOutputBlocksOfflineAndOnlineRuntime},

  563.     });

  564. }