suyu
/
suyu_two
1
0
Fork 0
Koodi Ongelmat 0 Pull-pyynnöt 0 Julkaisut 0 Wiki Toiminta
综合平台编程器项目的远程存储
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.
163 Commitit
1 Haara
183 MiB
 
 
 
 
Puu: ca12b7427c
Branchit Tagit
${ item.name }
Create branch ${ searchTerm }
from 'ca12b7427c'
${ noResults }
suyu_two/app/tests/runtime_mode_service_tests.cpp

598 rivejä
24 KiB
Raaka Blame Historia 

  1. #include "services/runtime_mode_service.h"

  2. #include "services/user_runtime_plc_recovery_policy.h"

  3. #include "services/logic_editor_service.h"

  4. #include "services/offline_simulation_service.h"

  5. #include "services/project_service.h"

  6. #include "domain/active_register_repository.h"

  7. #include "domain/project_storage.h"

  8. #include "domain/register_repository.h"

  9. #include "domain/virtual_register_repository.h"

  10. #include "infrastructure/plc_register_repository.h"

  11. #include "support/test_support.h"

  12. 

  13. #include <functional>

  14. #include <iostream>

  15. #include <stdexcept>

  16. #include <string>

  17. #include <utility>

  18. 

  19. namespace {

  20. 

  21. using TestProjectStorage = TestSupport::InMemoryProjectStorage;

  22. 

  23. class ReadyPlcGateway final : public PlcCommunicationGateway

  24. {

  25. public:

  26.     PlcCommunicationResult connectDevice(const PlcSerialConfiguration &) override

  27.     {

  28.         connection_state = PlcConnectionState::Connected;

  29.         if (state_changed)

  30.         {

  31.             state_changed();

  32.         }

  33.         return {true, {}};

  34.     }

  35. 

  36.     void disconnectDevice() override

  37.     {

  38.         connection_state = PlcConnectionState::Disconnected;

  39.         initial_read = false;

  40.     }

  41. 

  42.     PlcCommunicationResult setPollAddresses(

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

  44.     {

  45.         return setPollAddresses(addresses, {});

  46.     }

  47. 

  48.     PlcCommunicationResult setPollAddresses(

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

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

  51.     {

  52.         if (reject_poll_configuration)

  53.         {

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

  55.         }

  56.         poll_addresses = addresses;

  57.         poll_ranges = ranges;

  58.         return {true, {}};

  59.     }

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

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

  62.     PlcCommunicationError lastErrorType() const override

  63.     {

  64.         return PlcCommunicationError::None;

  65.     }

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

  67. 

  68.     void setCallbacks(

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

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

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

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

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

  74.     {

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

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

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

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

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

  80.     }

  81. 

  82.     void completeInitialRead()

  83.     {

  84.         initial_read = true;

  85.         if (initial_read_changed)

  86.         {

  87.             initial_read_changed(true);

  88.         }

  89.     }

  90. 

  91.     void completePollCycle()

  92.     {

  93.         if (poll_cycle_completed)

  94.         {

  95.             poll_cycle_completed();

  96.         }

  97.     }

  98. 

  99.     void reportFault()

  100.     {

  101.         connection_state = PlcConnectionState::Faulted;

  102.         initial_read = false;

  103.         if (state_changed)

  104.         {

  105.             state_changed();

  106.         }

  107.     }

  108. 

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

  110.     {

  111.         return poll_addresses;

  112.     }

  113. 

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

  115.     {

  116.         return poll_ranges;

  117.     }

  118. 

  119.     bool reject_poll_configuration = false;

  120. 

  121. private:

  122.     PlcConnectionState connection_state = PlcConnectionState::Disconnected;

  123.     bool initial_read = false;

  124.     std::string last_error;

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

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

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

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

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

  130.     std::vector<RegisterAddress> poll_addresses;

  131.     std::vector<RegisterWordRange> poll_ranges;

  132. };

  133. 

  134. using TestSupport::require;

  135. 

  136. void testUserRuntimePlcRecoveryPolicy()

  137. {

  138.     UserRuntimePlcRecoveryPolicy policy;

  139.     require(

  140.         policy.shouldReconnectSerial(PlcConnectionState::Disconnected),

  141.         "a disconnected local serial port must use a full reconnect");

  142.     require(

  143.         !policy.shouldReconnectSerial(PlcConnectionState::Faulted),

  144.         "a PLC communication fault must keep the serial session for recovery probing");

  145. 

  146.     require(

  147.         policy.beginFailureEpisode() && policy.failureEpisodeActive(),

  148.         "the first error in one communication outage must be reported");

  149.     require(

  150.         !policy.beginFailureEpisode(),

  151.         "later error changes in the same outage must not be reported again");

  152. 

  153.     policy.observeStatus(PlcConnectionState::Connected, false);

  154.     require(

  155.         policy.failureEpisodeActive(),

  156.         "opening the serial port without a complete PLC read must not end the outage");

  157.     policy.observeStatus(PlcConnectionState::Recovering, true);

  158.     require(

  159.         policy.failureEpisodeActive(),

  160.         "a recovering connection must remain in the same outage until fully connected");

  161.     policy.observeStatus(PlcConnectionState::Connected, true);

  162.     require(

  163.         !policy.failureEpisodeActive() && policy.beginFailureEpisode(),

  164.         "a connected PLC with a complete first read must allow a later outage to report once");

  165. }

  166. 

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

  168. {

  169.     for (int column = 0;

  170.          column < ProjectLimits::kMaximumConditionColumns;

  171.          ++column)

  172.     {

  173.         rung->cells.push_back({

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

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

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

  177.     }

  178. }

  179. 

  180. void testModeTransitions()

  181. {

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

  183.     TestProjectStorage storage;

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

  185.     VirtualRegisterRepository virtual_repository;

  186.     VirtualRegisterRepository plc_repository;

  187.     ActiveRegisterRepository active_repository(virtual_repository);

  188.     OfflineSimulationService simulation_service(virtual_repository);

  189.     OnlineLogicMonitorService online_monitor_service(plc_repository);

  190.     LogicEditorService logic_editor_service(project_service);

  191.     ReadyPlcGateway gateway;

  192.     RuntimeModeService service(

  193.         project_service,

  194.         logic_editor_service,

  195.         simulation_service,

  196.         online_monitor_service);

  197.     service.configurePlc(

  198.         gateway, active_repository, virtual_repository, plc_repository);

  199. 

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

  201.     HmiPage page;

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

  203.     page.name = "Runtime";

  204.     HmiControl int32_display;

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

  206.     int32_display.type = HmiControlType::NumericDisplay;

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

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

  209.     int32_display.dataType = RegisterDataType::Int32;

  210.     page.controls.push_back(int32_display);

  211.     HmiControl double_display = int32_display;

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

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

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

  215.     double_display.dataType = RegisterDataType::Float64;

  216.     page.controls.push_back(double_display);

  217.     HmiControl double_status = int32_display;

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

  219.     double_status.type = HmiControlType::StatusText;

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

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

  222.     double_status.dataType = RegisterDataType::Float64;

  223.     double_status.statusText = HmiStatusWordTextConfig{{

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

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

  226.     page.controls.push_back(double_status);

  227.     HmiControl gated_button;

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

  229.     gated_button.type = HmiControlType::Button;

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

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

  232.     gated_button.buttonEnableCondition = HmiButtonWordEnableCondition{

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

  234.         RegisterDataType::Int32,

  235.         HmiButtonConditionOperator::GreaterThanOrEqual,

  236.         1.0};

  237.     page.controls.push_back(gated_button);

  238.     project.initialHmiPageId = page.id;

  239.     project.hmiPages.push_back(page);

  240.     project.alarmDefinitions.push_back(

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

  242.     project.alarmDefinitions.push_back(

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

  244.     project.registerComments = {

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

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

  247. 

  248.     ControlLogic logic;

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

  250.     logic.name = "Poll logic";

  251.     LogicNode edge;

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

  253.     edge.config = EdgeContactNodeConfig{

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

  255.     LogicNode edge_coil;

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

  257.     edge_coil.config = CoilNodeConfig{

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

  259.     LadderRung edge_rung;

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

  261.     edge_rung.name = "Poll edge";

  262.     setConditionPath(&edge_rung, edge);

  263.     edge_rung.output = edge_coil;

  264.     logic.rungs.push_back(edge_rung);

  265.     LogicNode comparison;

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

  267.     comparison.config = CompareNodeConfig{

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

  269.     LogicNode comparison_coil;

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

  271.     comparison_coil.config = CoilNodeConfig{

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

  273.     LadderRung comparison_rung;

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

  275.     comparison_rung.name = "Poll comparison";

  276.     setConditionPath(&comparison_rung, comparison);

  277.     comparison_rung.output = comparison_coil;

  278.     logic.rungs.push_back(comparison_rung);

  279.     LogicNode move_input;

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

  281.     move_input.config = ContactNodeConfig{

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

  283.     LogicNode move_output;

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

  285.     move_output.config = MoveNodeConfig{

  286.         WordOperand{

  287.             WordOperandKind::Register,

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

  289.             0},

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

  291.     LadderRung move_rung;

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

  293.     move_rung.name = "Poll MOVE";

  294.     setConditionPath(&move_rung, move_input);

  295.     move_rung.output = move_output;

  296.     logic.rungs.push_back(move_rung);

  297.     LogicNode add_input;

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

  299.     add_input.config = ContactNodeConfig{

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

  301.     LogicNode add_output;

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

  303.     add_output.config = ArithmeticNodeConfig{

  304.         ArithmeticOperation::Add,

  305.         WordOperand{

  306.             WordOperandKind::Register,

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

  308.             0},

  309.         WordOperand{

  310.             WordOperandKind::Constant,

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

  312.             1},

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

  314.     LadderRung add_rung;

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

  316.     add_rung.name = "Poll ADD";

  317.     setConditionPath(&add_rung, add_input);

  318.     add_rung.output = add_output;

  319.     logic.rungs.push_back(add_rung);

  320.     project.controlLogics.push_back(logic);

  321. 

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

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

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

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

  326. 

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

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

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

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

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

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

  333.     require(service.enterOnlineRunning().error

  334.                 == ModeTransitionError::MustReturnToEditing,

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

  336. 

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

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

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

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

  341.     require(service.enterOnlineRunning().error

  342.                 == ModeTransitionError::InitialPlcReadRequired,

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

  344. 

  345.     require(service.connectPlc(

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

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

  348.     require(gateway.pollAddresses()

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

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

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

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

  353.                     {RegisterArea::M, 30},

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

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

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

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

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

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

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

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

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

  363.                 && gateway.pollRanges()

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

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

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

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

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

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

  370.     gateway.completeInitialRead();

  371.     require(service.initialPlcReadCompleted(),

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

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

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

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

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

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

  378.     require(service.onlineLogicMonitorService().state()

  379.                 == OnlineLogicMonitorState::Running,

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

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

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

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

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

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

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

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

  388.         .successfulScanCount();

  389.     gateway.completePollCycle();

  390.     require(service.onlineLogicMonitorService().successfulScanCount()

  391.                 == scan_count + 1U,

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

  393. }

  394. 

  395. void testHmiOnlyRuntimeSkipsLogicExecutor()

  396. {

  397.     TestProjectStorage storage;

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

  399.     VirtualRegisterRepository virtual_repository;

  400.     PlcRegisterRepository plc_repository;

  401.     ActiveRegisterRepository active_repository(virtual_repository);

  402.     OfflineSimulationService simulation_service(virtual_repository);

  403.     OnlineLogicMonitorService online_monitor_service(plc_repository);

  404.     LogicEditorService logic_editor_service(project_service);

  405.     ReadyPlcGateway gateway;

  406.     RuntimeModeService service(

  407.         project_service,

  408.         logic_editor_service,

  409.         simulation_service,

  410.         online_monitor_service);

  411.     service.configurePlc(

  412.         gateway, active_repository, virtual_repository, plc_repository);

  413.     service.setHmiOnlyRuntime(true);

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

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

  416. 

  417.     HmiPage page;

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

  419.     page.name = "HMI only";

  420.     HmiControl button;

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

  422.     button.type = HmiControlType::Button;

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

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

  425.     page.controls.push_back(button);

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

  427.     project.hmiPages.push_back(page);

  428.     project.initialHmiPageId = page.id;

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

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

  431. 

  432.     require(service.connectPlc(

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

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

  435.     gateway.completeInitialRead();

  436.     plc_repository.updateBit(0, false);

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

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

  439.     require(service.policy().usesPlcRegisters

  440.                 && online_monitor_service.state()

  441.                     == OnlineLogicMonitorState::Stopped,

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

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

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

  445.     plc_repository.updateBit(0, true);

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

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

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

  449.     plc_repository.invalidate();

  450.     gateway.reportFault();

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

  452.                 && !service.initialPlcReadCompleted()

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

  454.                     == RegisterError::Unavailable,

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

  456. }

  457. 

  458. void testMonitorPollRangeRollback()

  459. {

  460.     TestProjectStorage storage;

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

  462.     VirtualRegisterRepository virtual_repository;

  463.     VirtualRegisterRepository plc_repository;

  464.     ActiveRegisterRepository active_repository(virtual_repository);

  465.     OfflineSimulationService simulation_service(virtual_repository);

  466.     OnlineLogicMonitorService online_monitor_service(plc_repository);

  467.     LogicEditorService logic_editor_service(project_service);

  468.     ReadyPlcGateway gateway;

  469.     RuntimeModeService service(

  470.         project_service,

  471.         logic_editor_service,

  472.         simulation_service,

  473.         online_monitor_service);

  474.     service.configurePlc(

  475.         gateway, active_repository, virtual_repository, plc_repository);

  476. 

  477.     gateway.reject_poll_configuration = true;

  478.     const PlcCommunicationResult rejected = service.setMonitorAddresses(

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

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

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

  482.     require(!rejected.succeeded,

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

  484. 

  485.     gateway.reject_poll_configuration = false;

  486.     require(service.refreshPlcPollAddresses().succeeded

  487.                 && gateway.pollAddresses().empty()

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

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

  490. }

  491. 

  492. void testDisconnectedOutputBlocksOfflineAndOnlineRuntime()

  493. {

  494.     TestProjectStorage storage;

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

  496.     VirtualRegisterRepository virtual_repository;

  497.     VirtualRegisterRepository plc_repository;

  498.     ActiveRegisterRepository active_repository(virtual_repository);

  499.     OfflineSimulationService simulation_service(virtual_repository);

  500.     OnlineLogicMonitorService online_monitor_service(plc_repository);

  501.     LogicEditorService logic_editor_service(project_service);

  502.     ReadyPlcGateway gateway;

  503.     RuntimeModeService service(

  504.         project_service,

  505.         logic_editor_service,

  506.         simulation_service,

  507.         online_monitor_service);

  508.     service.configurePlc(

  509.         gateway, active_repository, virtual_repository, plc_repository);

  510. 

  511.     ControlLogic logic;

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

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

  514.     LadderRung rung;

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

  516.     rung.name = "行 1";

  517.     for (int column = 0;

  518.          column < ProjectLimits::kMaximumConditionColumns;

  519.          ++column)

  520.     {

  521.         rung.cells.push_back({

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

  523.             LadderCellKind::Gap,

  524.             std::nullopt});

  525.     }

  526.     rung.output = LogicNode{

  527.         "broken-output",

  528.         CoilNodeConfig{

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

  530.         true};

  531.     logic.rungs.push_back(rung);

  532.     LadderRung unused;

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

  534.     unused.name = "行 2";

  535.     for (int column = 0;

  536.          column < ProjectLimits::kMaximumConditionColumns;

  537.          ++column)

  538.     {

  539.         unused.cells.push_back({

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

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

  542.                 ? LadderCellKind::Wire : LadderCellKind::Gap,

  543.             std::nullopt});

  544.     }

  545.     logic.rungs.push_back(unused);

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

  547.     logic_editor_service.clearHistory();

  548. 

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

  550.     require(

  551.         !offline.succeeded

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

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

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

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

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

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

  558.             && service.lastSyntaxCheck().changed

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

  560.             && logic_editor_service.findCell(

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

  562.                 == LadderCellKind::Gap

  563.             && logic_editor_service.canUndo(),

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

  565. 

  566.     require(service.connectPlc(

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

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

  569.     gateway.completeInitialRead();

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

  571.     require(

  572.         !online.succeeded

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

  574.             && online.detail == offline.detail

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

  576.             && online_monitor_service.state()

  577.                 == OnlineLogicMonitorState::Stopped

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

  579.             && logic_editor_service.undo().succeeded

  580.             && logic_editor_service.findCell(

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

  582.                 == LadderCellKind::Wire,

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

  584. }

  585. 

  586. } // namespace

  587. 

  588. int main()

  589. {

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

  591.         {"testUserRuntimePlcRecoveryPolicy", testUserRuntimePlcRecoveryPolicy},

  592.         {"testModeTransitions", testModeTransitions},

  593.         {"testHmiOnlyRuntimeSkipsLogicExecutor", testHmiOnlyRuntimeSkipsLogicExecutor},

  594.         {"testMonitorPollRangeRollback", testMonitorPollRangeRollback},

  595.         {"testDisconnectedOutputBlocksOfflineAndOnlineRuntime", testDisconnectedOutputBlocksOfflineAndOnlineRuntime},

  596.     });

  597. }