suyu
/
suyu_two
1
0
Atdalīts 0
Kods Problēmas 0 Izmaiņu pieprasījumi 0 Laidieni 0 Vikivietne Aktivitāte
综合平台编程器项目的远程存储
Nevar pievienot vairāk kā 25 tēmas Tēmai ir jāsākas ar burtu vai ciparu, tā var saturēt domu zīmes ('-') un var būt līdz 35 simboliem gara.
75 Revīzijas
1 Atzars
183 MiB
 
 
 
 
Koks: 2fa8c1f226
Atzari Tagi
${ item.name }
Izveidot atzaru ${ searchTerm }
no '2fa8c1f226'
${ noResults }
suyu_two/app/tests/project_management_tests.cpp

781 rinda
35 KiB
Neapstrādāts Vainot Vēsture 

  1. #include "domain/project_storage.h"

  2. #include "infrastructure/json_project_storage.h"

  3. #include "services/register_comment_service.h"

  4. #include "services/project_service.h"

  5. 

  6. #include <QFile>

  7. #include <QJsonArray>

  8. #include <QJsonDocument>

  9. #include <QJsonObject>

  10. #include <QTemporaryDir>

  11. 

  12. #include <exception>

  13. #include <iostream>

  14. #include <stdexcept>

  15. #include <string>

  16. #include <utility>

  17. 

  18. namespace {

  19. 

  20. void require(bool condition, const std::string &message)

  21. {

  22.     if (!condition)

  23.     {

  24.         throw std::runtime_error(message);

  25.     }

  26. }

  27. 

  28. Project makeExampleProject()

  29. {

  30.     // 构造覆盖 HMI 控件和梯形图串并联结构的完整 JSON 往返样本

  31.     HmiControl start_button;

  32.     start_button.id = "start-button";

  33.     start_button.type = HmiControlType::Button;

  34.     start_button.bounds = {10, 20, 120, 48};

  35.     start_button.text = "Start";

  36.     start_button.binding = RegisterAddress{RegisterArea::M, 0};

  37.     start_button.buttonOperation = HmiButtonOperation::SetOn;

  38.     start_button.properties.emplace("color", "green");

  39. 

  40.     HmiControl running_indicator;

  41.     running_indicator.id = "running-indicator";

  42.     running_indicator.type = HmiControlType::Indicator;

  43.     running_indicator.bounds = {150, 20, 64, 64};

  44.     running_indicator.text = "Running";

  45.     running_indicator.binding = RegisterAddress{RegisterArea::M, 1};

  46.     running_indicator.properties.emplace("activeColor", "#24a148");

  47. 

  48.     HmiControl temperature_display;

  49.     temperature_display.id = "temperature-display";

  50.     temperature_display.type = HmiControlType::NumericDisplay;

  51.     temperature_display.bounds = {10, 90, 120, 40};

  52.     temperature_display.text = "Temperature";

  53.     temperature_display.binding = RegisterAddress{RegisterArea::D, 2};

  54.     temperature_display.properties.emplace("format", "decimal");

  55. 

  56.     HmiControl target_input;

  57.     target_input.id = "target-input";

  58.     target_input.type = HmiControlType::NumericInput;

  59.     target_input.bounds = {150, 90, 120, 40};

  60.     target_input.text = "Target";

  61.     target_input.binding = RegisterAddress{RegisterArea::D, 3};

  62.     target_input.properties.emplace("minimum", "-100");

  63. 

  64.     HmiControl title_label;

  65.     title_label.id = "title-label";

  66.     title_label.type = HmiControlType::Label;

  67.     title_label.bounds = {10, 145, 180, 32};

  68.     title_label.text = "Production line";

  69. 

  70.     HmiControl settings_jump;

  71.     settings_jump.id = "settings-jump";

  72.     settings_jump.type = HmiControlType::PageJump;

  73.     settings_jump.bounds = {210, 145, 120, 40};

  74.     settings_jump.text = "Settings";

  75.     settings_jump.pageJump = HmiPageJumpConfig{"settings-page"};

  76. 

  77.     HmiControl alarm_list;

  78.     alarm_list.id = "alarm-list";

  79.     alarm_list.type = HmiControlType::AlarmList;

  80.     alarm_list.bounds = {10, 200, 360, 180};

  81.     alarm_list.text = "Alarms";

  82. 

  83.     HmiControl progress_bar;

  84.     progress_bar.id = "progress-bar";

  85.     progress_bar.type = HmiControlType::ProgressBar;

  86.     progress_bar.bounds = {400, 20, 240, 36};

  87.     progress_bar.text = "Completion";

  88.     progress_bar.binding = RegisterAddress{RegisterArea::D, 4};

  89.     progress_bar.progressBar = HmiProgressBarConfig{-20, 80, true};

  90. 

  91.     HmiPage page;

  92.     page.id = "main-page";

  93.     page.name = "Main";

  94.     page.controls.push_back(start_button);

  95.     page.controls.push_back(running_indicator);

  96.     page.controls.push_back(temperature_display);

  97.     page.controls.push_back(target_input);

  98.     page.controls.push_back(title_label);

  99.     page.controls.push_back(settings_jump);

  100.     page.controls.push_back(alarm_list);

  101.     page.controls.push_back(progress_bar);

  102. 

  103.     HmiPage settings_page;

  104.     settings_page.id = "settings-page";

  105.     settings_page.name = "Settings";

  106. 

  107.     LogicNode contact;

  108.     contact.id = "start-contact";

  109.     contact.config = ContactNodeConfig{

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

  111.         ContactMode::NormallyOpen};

  112. 

  113.     LogicNode compare;

  114.     compare.id = "temperature-check";

  115.     compare.config = CompareNodeConfig{

  116.         RegisterAddress{RegisterArea::D, 2},

  117.         ComparisonOperator::GreaterThanOrEqual,

  118.         static_cast<std::int16_t>(100)};

  119. 

  120.     LogicNode hold_contact;

  121.     hold_contact.id = "hold-contact";

  122.     hold_contact.config = ContactNodeConfig{

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

  124.         ContactMode::NormallyOpen};

  125. 

  126.     LogicNode coil;

  127.     coil.id = "run-coil";

  128.     coil.config = CoilNodeConfig{

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

  130.         CoilMode::Set};

  131. 

  132.     ControlLogic logic;

  133.     logic.id = "start-logic";

  134.     logic.name = "Start logic";

  135.     logic.enabled = false;

  136.     LadderRung rung;

  137.     rung.id = "rung-1";

  138.     rung.name = "Network 1";

  139.     rung.comment = "启动条件与温度检查";

  140.     ConditionExpression parallel;

  141.     parallel.id = "parallel-start";

  142.     parallel.kind = ConditionExpressionKind::Parallel;

  143.     parallel.children = {

  144.         ConditionExpression::fromNode(contact),

  145.         ConditionExpression::fromNode(hold_contact)};

  146.     ConditionExpression series;

  147.     series.id = "series-root";

  148.     series.kind = ConditionExpressionKind::Series;

  149.     series.children = {

  150.         std::move(parallel),

  151.         ConditionExpression::fromWire("start-wire", 2),

  152.         ConditionExpression::fromNode(compare)};

  153.     rung.condition = std::move(series);

  154.     rung.output = coil;

  155.     logic.rungs.push_back(rung);

  156. 

  157.     LogicNode rising_edge;

  158.     rising_edge.id = "rising-edge";

  159.     rising_edge.config = EdgeContactNodeConfig{

  160.         RegisterAddress{RegisterArea::M, 4}, EdgeMode::Rising};

  161.     LogicNode ton_output;

  162.     ton_output.id = "ton-output";

  163.     ton_output.config = TonNodeConfig{TimerAddress{7}, 2500};

  164.     LadderRung ton_rung;

  165.     ton_rung.id = "ton-rung";

  166.     ton_rung.name = "TON network";

  167.     ton_rung.comment = "延时启动";

  168.     ton_rung.condition = ConditionExpression::fromNode(rising_edge);

  169.     ton_rung.output = ton_output;

  170.     logic.rungs.push_back(ton_rung);

  171. 

  172.     LogicNode falling_edge;

  173.     falling_edge.id = "falling-edge";

  174.     falling_edge.config = EdgeContactNodeConfig{

  175.         RegisterAddress{RegisterArea::M, 5}, EdgeMode::Falling};

  176.     LogicNode timer_contact;

  177.     timer_contact.id = "timer-contact";

  178.     timer_contact.config = TimerContactNodeConfig{

  179.         TimerAddress{7}, ContactMode::NormallyOpen};

  180.     LogicNode timer_coil;

  181.     timer_coil.id = "timer-coil";

  182.     timer_coil.config = CoilNodeConfig{

  183.         RegisterAddress{RegisterArea::M, 6}, CoilMode::Normal};

  184.     LadderRung timer_rung;

  185.     timer_rung.id = "timer-rung";

  186.     timer_rung.name = "Timer feedback";

  187.     timer_rung.comment = "定时器完成反馈";

  188.     ConditionExpression timer_series;

  189.     timer_series.id = "timer-series";

  190.     timer_series.kind = ConditionExpressionKind::Series;

  191.     timer_series.children = {

  192.         ConditionExpression::fromNode(falling_edge),

  193.         ConditionExpression::fromNode(timer_contact)};

  194.     timer_rung.condition = std::move(timer_series);

  195.     timer_rung.output = timer_coil;

  196.     logic.rungs.push_back(timer_rung);

  197. 

  198.     LogicNode counter_input;

  199.     counter_input.id = "counter-input";

  200.     counter_input.config = ContactNodeConfig{

  201.         RegisterAddress{RegisterArea::M, 7}, ContactMode::NormallyOpen};

  202.     LogicNode counter_output;

  203.     counter_output.id = "counter-output";

  204.     counter_output.config = CounterNodeConfig{

  205.         CounterAddress{3},

  206.         CounterMode::Up,

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

  208.         WordOperand{

  209.             WordOperandKind::Register,

  210.             RegisterAddress{RegisterArea::D, 11},

  211.             0},

  212.         RegisterAddress{RegisterArea::M, 8}};

  213.     LadderRung counter_rung;

  214.     counter_rung.id = "counter-rung";

  215.     counter_rung.name = "Counter network";

  216.     counter_rung.comment = "计数器上升沿计数";

  217.     counter_rung.condition = ConditionExpression::fromNode(counter_input);

  218.     counter_rung.output = counter_output;

  219.     logic.rungs.push_back(counter_rung);

  220. 

  221.     LogicNode counter_contact;

  222.     counter_contact.id = "counter-contact";

  223.     counter_contact.config = CounterContactNodeConfig{

  224.         CounterAddress{3}, ContactMode::NormallyOpen};

  225.     LogicNode counter_coil;

  226.     counter_coil.id = "counter-coil";

  227.     counter_coil.config = CoilNodeConfig{

  228.         RegisterAddress{RegisterArea::M, 9}, CoilMode::Normal};

  229.     LadderRung counter_feedback_rung;

  230.     counter_feedback_rung.id = "counter-feedback-rung";

  231.     counter_feedback_rung.name = "Counter feedback";

  232.     counter_feedback_rung.condition = ConditionExpression::fromNode(counter_contact);

  233.     counter_feedback_rung.output = counter_coil;

  234.     logic.rungs.push_back(counter_feedback_rung);

  235. 

  236.     const auto addDataRung = [&logic](

  237.         const std::string &rung_id,

  238.         const std::string &input_id,

  239.         int input_address,

  240.         LogicNode output)

  241.     {

  242.         LogicNode input;

  243.         input.id = input_id;

  244.         input.config = ContactNodeConfig{

  245.             RegisterAddress{RegisterArea::M, input_address},

  246.             ContactMode::NormallyOpen};

  247.         LadderRung data_rung;

  248.         data_rung.id = rung_id;

  249.         data_rung.name = rung_id;

  250.         data_rung.condition = ConditionExpression::fromNode(input);

  251.         data_rung.output = std::move(output);

  252.         logic.rungs.push_back(std::move(data_rung));

  253.     };

  254.     addDataRung(

  255.         "move-rung",

  256.         "move-input",

  257.         20,

  258.         LogicNode{

  259.             "move-output",

  260.             MoveNodeConfig{

  261.                 WordOperand{

  262.                     WordOperandKind::Constant,

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

  264.                     25},

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

  266.             true});

  267.     addDataRung(

  268.         "add-rung",

  269.         "add-input",

  270.         21,

  271.         LogicNode{

  272.             "add-output",

  273.             ArithmeticNodeConfig{

  274.                 ArithmeticOperation::Add,

  275.                 WordOperand{

  276.                     WordOperandKind::Register,

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

  278.                     0},

  279.                 WordOperand{

  280.                     WordOperandKind::Constant,

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

  282.                     1},

  283.                 RegisterAddress{RegisterArea::D, 21}},

  284.             true});

  285.     addDataRung(

  286.         "sub-rung",

  287.         "sub-input",

  288.         22,

  289.         LogicNode{

  290.             "sub-output",

  291.             ArithmeticNodeConfig{

  292.                 ArithmeticOperation::Subtract,

  293.                 WordOperand{

  294.                     WordOperandKind::Register,

  295.                     RegisterAddress{RegisterArea::D, 21},

  296.                     0},

  297.                 WordOperand{

  298.                     WordOperandKind::Constant,

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

  300.                     1},

  301.                 RegisterAddress{RegisterArea::D, 22}},

  302.             true});

  303. 

  304.     Project project;

  305.     project.metadata = {"example-project", "Example project", "1.0"};

  306.     project.hmiPages.push_back(page);

  307.     project.hmiPages.push_back(settings_page);

  308.     project.initialHmiPageId = page.id;

  309.     project.alarmDefinitions.push_back(

  310.         {"alarm-emergency",

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

  312.          AlarmCondition::MOn,

  313.          0,

  314.          "Emergency stop"});

  315.     project.alarmDefinitions.push_back(

  316.         {"alarm-temperature",

  317.          RegisterAddress{RegisterArea::D, 2},

  318.          AlarmCondition::DHigh,

  319.          80,

  320.          "Temperature high"});

  321.     project.registerComments = {

  322.         {RegisterAddress{RegisterArea::M, 0}, "启动按钮"},

  323.         {RegisterAddress{RegisterArea::D, 2}, "当前温度"}};

  324.     project.controlLogics.push_back(logic);

  325.     ControlLogic draft_logic;

  326.     draft_logic.id = "draft-logic";

  327.     draft_logic.name = "Draft logic";

  328.     draft_logic.enabled = false;

  329.     draft_logic.rungs.push_back(

  330.         {"rung-1", "Draft network", {}, std::nullopt, std::nullopt});

  331.     project.controlLogics.push_back(draft_logic);

  332.     return project;

  333. }

  334. 

  335. void writeText(const QString &path, const QByteArray &content)

  336. {

  337.     // 直接写入故障样本文件，以验证加载失败时的保护行为

  338.     QFile file(path);

  339.     require(file.open(QIODevice::WriteOnly), "test file must be writable");

  340.     require(file.write(content) == content.size(), "test file must be written completely");

  341. }

  342. 

  343. QByteArray readBytes(const QString &path)

  344. {

  345.     QFile file(path);

  346.     require(file.open(QIODevice::ReadOnly), "saved project must be readable");

  347.     return file.readAll();

  348. }

  349. 

  350. void testEmptyProjectRoundTrip()

  351. {

  352.     // 空工程是合法工程，保存再加载后不应凭空产生页面或逻辑

  353.     QTemporaryDir directory;

  354.     require(directory.isValid(), "temporary directory must be valid");

  355. 

  356.     JsonProjectStorage storage;

  357.     ProjectService service(storage);

  358.     require(service.createNewProject("Empty project").succeeded,

  359.             "empty project creation must succeed");

  360. 

  361.     const QString path = directory.filePath("empty.json");

  362.     require(service.saveAs(path.toStdString()).succeeded,

  363.             "empty project save must succeed");

  364.     require(!service.isModified(), "saved project must not be marked modified");

  365. 

  366.     require(service.load(path.toStdString()).succeeded,

  367.             "empty project load must succeed");

  368.     require(service.project().metadata.name == "Empty project",

  369.             "empty project name must survive round trip");

  370.     require(service.project().hmiPages.empty(), "empty project must have no HMI pages");

  371.     require(service.project().controlLogics.empty(),

  372.             "empty project must have no control logics");

  373.     require(service.project().alarmDefinitions.empty(),

  374.             "empty project must have no alarm definitions");

  375. }

  376. 

  377. void testExampleProjectRoundTrip()

  378. {

  379.     // 验证各层嵌套字段往返后保持不变且序列化结果稳定

  380.     QTemporaryDir directory;

  381.     require(directory.isValid(), "temporary directory must be valid");

  382. 

  383.     JsonProjectStorage storage;

  384.     ProjectService service(storage);

  385.     service.editProject() = makeExampleProject();

  386. 

  387.     const QString first_path = directory.filePath("example.json");

  388.     const QString second_path = directory.filePath("example-copy.json");

  389.     const QString invalid_operation_path = directory.filePath("invalid-operation.json");

  390.     const QString missing_initial_path = directory.filePath("missing-initial.json");

  391.     const QString missing_target_path = directory.filePath("missing-target.json");

  392.     const QString missing_progress_range_path = directory.filePath(

  393.         "missing-progress-range.json");

  394.     const QString missing_alarms_path = directory.filePath("missing-alarms.json");

  395.     const QString missing_register_comments_path = directory.filePath(

  396.         "missing-register-comments.json");

  397.     const QString missing_rung_comment_path = directory.filePath(

  398.         "missing-rung-comment.json");

  399.     require(service.saveAs(first_path.toStdString()).succeeded,

  400.             "example project save must succeed");

  401.     const QByteArray saved_json = readBytes(first_path);

  402.     require(saved_json.contains("\"rungs\"")

  403.                 && saved_json.contains("\"condition\"")

  404.                 && saved_json.contains("\"children\"")

  405.                 && saved_json.contains("\"output\""),

  406.             "saved project must use structured ladder expressions");

  407.     require(!saved_json.contains("\"dataPoints\""),

  408.             "saved project must not contain the removed data point model");

  409.     require(saved_json.contains("\"formatVersion\": \"1.0\"")

  410.                 && saved_json.contains("\"buttonOperation\": \"setOn\"")

  411.                 && saved_json.contains("\"initialHmiPageId\": \"main-page\"")

  412.                 && saved_json.contains("\"targetPageId\": \"settings-page\"")

  413.                 && saved_json.contains("\"alarmDefinitions\"")

  414.                 && saved_json.contains("\"registerComments\"")

  415.                 && saved_json.contains("\"text\": \"启动按钮\"")

  416.                 && saved_json.contains("\"type\": \"edgeContact\"")

  417.                 && saved_json.contains("\"type\": \"timerContact\"")

  418.                 && saved_json.contains("\"type\": \"ton\"")

  419.                 && saved_json.contains("\"type\": \"counterContact\"")

  420.                 && saved_json.contains("\"type\": \"counter\"")

  421.                 && saved_json.contains("\"type\": \"move\"")

  422.                 && saved_json.contains("\"type\": \"arithmetic\"")

  423.                 && saved_json.contains("\"operation\": \"add\"")

  424.                 && saved_json.contains("\"operation\": \"subtract\"")

  425.                 && saved_json.contains("\"comment\": \"启动条件与温度检查\"")

  426.                 && saved_json.contains("\"type\": \"alarmList\"")

  427.                 && saved_json.contains("\"type\": \"progressBar\"")

  428.                 && saved_json.contains("\"minimumValue\": -20")

  429.                 && saved_json.contains("\"maximumValue\": 80")

  430.                 && saved_json.contains("\"showValue\": true"),

  431.             "version 1.0 projects must persist pages and alarm definitions");

  432.     require(!saved_json.contains("\"stages\"")

  433.                 && !saved_json.contains("\"branches\""),

  434.             "current project format must not contain the removed stage model");

  435.     require(!saved_json.contains("\"position\"")

  436.                 && !saved_json.contains("\"connections\""),

  437.             "saved ladder logic must not contain free-graph fields");

  438.     require(service.load(first_path.toStdString()).succeeded,

  439.             "example project load must succeed");

  440. 

  441.     const Project &project = service.project();

  442.     require(project.metadata.id == "example-project", "project id must survive round trip");

  443.     require(project.hmiPages.size() == 2, "HMI page count must survive round trip");

  444.     require(project.initialHmiPageId == "main-page",

  445.             "the initial HMI page id must survive round trip");

  446.     require(project.hmiPages.front().controls.size() == 8,

  447.             "register, navigation, AlarmList and ProgressBar controls must survive round trip");

  448.     require(project.hmiPages.front().controls.front().binding->area()

  449.                 == RegisterArea::M,

  450.             "HMI M binding must survive round trip");

  451.     require(project.hmiPages.front().controls.front().buttonOperation

  452.                 == HmiButtonOperation::SetOn,

  453.             "HMI button operation must survive round trip");

  454.     require(project.hmiPages.front().controls.front().properties.at("color") == "green",

  455.             "HMI properties must survive round trip");

  456.     require(project.hmiPages.front().controls.at(1).type == HmiControlType::Indicator,

  457.             "indicator control type must survive round trip");

  458.     require(project.hmiPages.front().controls.at(2).binding->area() == RegisterArea::D,

  459.             "numeric display D binding must survive round trip");

  460.     require(project.hmiPages.front().controls.at(3).bounds.x == 150,

  461.             "numeric input bounds must survive round trip");

  462.     require(project.hmiPages.front().controls.at(4).type == HmiControlType::Label

  463.                 && project.hmiPages.front().controls.at(5).pageJump->targetPageId

  464.                     == "settings-page",

  465.             "Label and PageJump typed data must survive round trip");

  466.     require(project.hmiPages.front().controls.at(6).type

  467.                 == HmiControlType::AlarmList,

  468.             "AlarmList control type must survive round trip");

  469.     require(project.hmiPages.front().controls.at(7).type

  470.                 == HmiControlType::ProgressBar

  471.                 && project.hmiPages.front().controls.at(7).progressBar.has_value()

  472.                 && project.hmiPages.front().controls.at(7).progressBar->minimumValue == -20

  473.                 && project.hmiPages.front().controls.at(7).progressBar->maximumValue == 80

  474.                 && project.hmiPages.front().controls.at(7).progressBar->showValue,

  475.             "ProgressBar configuration must survive round trip");

  476.     require(project.alarmDefinitions.size() == 2

  477.                 && project.alarmDefinitions.front().condition

  478.                     == AlarmCondition::MOn

  479.                 && project.alarmDefinitions.at(1).threshold == 80,

  480.             "M and D alarm definitions must survive round trip");

  481.     require(project.registerComments.size() == 2

  482.                 && project.registerComments.front().address.area() == RegisterArea::M

  483.                 && project.registerComments.front().text == "启动按钮"

  484.                 && project.registerComments.at(1).address.area() == RegisterArea::D,

  485.             "M/D register comments must survive round trip");

  486.     require(project.controlLogics.size() == 2,

  487.             "control logic count must survive round trip");

  488.     require(!project.controlLogics.front().enabled,

  489.             "control logic enabled state must survive round trip");

  490.     const LadderRung &rung = project.controlLogics.front().rungs.front();

  491.     require(rung.comment == "启动条件与温度检查",

  492.             "rung comments must survive round trip");

  493.     require(rung.condition.has_value()

  494.                 && rung.condition->kind == ConditionExpressionKind::Series,

  495.             "series root expression must survive round trip");

  496.     require(rung.condition->children.front().kind

  497.                 == ConditionExpressionKind::Parallel

  498.                 && rung.condition->children.front().children.size() == 2U,

  499.             "parallel expression branches must survive round trip");

  500.     require(rung.condition->children.at(1).kind == ConditionExpressionKind::Wire

  501.                 && rung.condition->children.at(1).wire->columnSpan == 2,

  502.             "horizontal wire span must survive JSON round trip");

  503.     require(rung.output.has_value(),

  504.             "ladder output must survive round trip");

  505. 

  506.     const LadderRung &ton_rung = project.controlLogics.front().rungs.at(1);

  507.     require(ton_rung.output.has_value()

  508.                 && std::holds_alternative<TonNodeConfig>(ton_rung.output->config)

  509.                 && std::get<TonNodeConfig>(ton_rung.output->config).address

  510.                     == TimerAddress{7}

  511.                 && std::get<TonNodeConfig>(ton_rung.output->config).presetMs == 2500,

  512.             "TON timer address and preset must survive round trip");

  513.     require(std::holds_alternative<EdgeContactNodeConfig>(

  514.                 ton_rung.condition->node->config)

  515.                 && std::get<EdgeContactNodeConfig>(ton_rung.condition->node->config).mode

  516.                     == EdgeMode::Rising,

  517.             "rising edge configuration must survive round trip");

  518.     const LadderRung &timer_rung = project.controlLogics.front().rungs.at(2);

  519.     require(timer_rung.comment == "定时器完成反馈"

  520.                 && std::holds_alternative<TimerContactNodeConfig>(

  521.                     timer_rung.condition->children.at(1).node->config)

  522.                 && std::get<TimerContactNodeConfig>(

  523.                     timer_rung.condition->children.at(1).node->config).address

  524.                     == TimerAddress{7}

  525.                 && std::holds_alternative<EdgeContactNodeConfig>(

  526.                     timer_rung.condition->children.front().node->config)

  527.                 && std::get<EdgeContactNodeConfig>(

  528.                     timer_rung.condition->children.front().node->config).mode

  529.                     == EdgeMode::Falling,

  530.             "falling edge and T contact configurations must survive round trip");

  531. 

  532.     const LadderRung &counter_rung = project.controlLogics.front().rungs.at(3);

  533.     const auto &counter = std::get<CounterNodeConfig>(counter_rung.output->config);

  534.     require(counter.address == CounterAddress{3}

  535.                 && counter.currentValueAddress == RegisterAddress{RegisterArea::D, 10}

  536.                 && counter.preset.kind == WordOperandKind::Register

  537.                 && counter.preset.address == RegisterAddress{RegisterArea::D, 11}

  538.                 && counter.resetAddress == RegisterAddress{RegisterArea::M, 8},

  539.             "counter resource and external M/D addresses must survive round trip");

  540.     const LadderRung &counter_feedback = project.controlLogics.front().rungs.at(4);

  541.     require(std::holds_alternative<CounterContactNodeConfig>(

  542.                 counter_feedback.condition->node->config)

  543.                 && std::get<CounterContactNodeConfig>(

  544.                     counter_feedback.condition->node->config).address

  545.                     == CounterAddress{3},

  546.             "counter contacts must survive round trip");

  547.     require(std::get<MoveNodeConfig>(

  548.                 project.controlLogics.front().rungs.at(5).output->config)

  549.                 .source.constant == 25,

  550.             "MOVE operands must survive round trip");

  551.     require(std::get<ArithmeticNodeConfig>(

  552.                 project.controlLogics.front().rungs.at(6).output->config)

  553.                 .operation == ArithmeticOperation::Add

  554.                 && std::get<ArithmeticNodeConfig>(

  555.                     project.controlLogics.front().rungs.at(7).output->config)

  556.                     .operation == ArithmeticOperation::Subtract,

  557.             "ADD and SUB operations must survive round trip");

  558. 

  559.     const auto &compare = std::get<CompareNodeConfig>(

  560.         rung.condition->children.at(2).node->config);

  561.     require(compare.address.index() == 2 && compare.value == 100,

  562.             "comparison configuration must survive round trip");

  563.     require(service.saveAs(second_path.toStdString()).succeeded,

  564.             "save as must succeed after load");

  565.     require(readBytes(first_path) == readBytes(second_path),

  566.             "save and save as must produce stable JSON");

  567. 

  568.     QByteArray invalid_operation = saved_json;

  569.     invalid_operation.replace(

  570.         "\"buttonOperation\": \"setOn\"",

  571.         "\"buttonOperation\": \"unsupported\"");

  572.     writeText(invalid_operation_path, invalid_operation);

  573.     require(!service.load(invalid_operation_path.toStdString()).succeeded,

  574.             "unsupported HMI button operations must be rejected");

  575. 

  576.     QJsonObject missing_initial = QJsonDocument::fromJson(saved_json).object();

  577.     missing_initial.remove(QStringLiteral("initialHmiPageId"));

  578.     writeText(

  579.         missing_initial_path,

  580.         QJsonDocument(missing_initial).toJson(QJsonDocument::Compact));

  581.     ProjectOperationResult missing_result = service.load(

  582.         missing_initial_path.toStdString());

  583.     require(!missing_result.succeeded

  584.                 && missing_result.storageError == ProjectStorageError::MissingField,

  585.             "the 1.0 schema must require initialHmiPageId without migration defaults");

  586. 

  587.     QJsonObject missing_alarms = QJsonDocument::fromJson(saved_json).object();

  588.     missing_alarms.remove(QStringLiteral("alarmDefinitions"));

  589.     writeText(

  590.         missing_alarms_path,

  591.         QJsonDocument(missing_alarms).toJson(QJsonDocument::Compact));

  592.     missing_result = service.load(missing_alarms_path.toStdString());

  593.     require(!missing_result.succeeded

  594.                 && missing_result.storageError == ProjectStorageError::MissingField,

  595.             "the 1.0 schema must require alarmDefinitions without migration defaults");

  596. 

  597.     QJsonObject missing_register_comments = QJsonDocument::fromJson(saved_json).object();

  598.     missing_register_comments.remove(QStringLiteral("registerComments"));

  599.     writeText(

  600.         missing_register_comments_path,

  601.         QJsonDocument(missing_register_comments).toJson(QJsonDocument::Compact));

  602.     missing_result = service.load(missing_register_comments_path.toStdString());

  603.     require(!missing_result.succeeded

  604.                 && missing_result.storageError == ProjectStorageError::MissingField,

  605.             "the 1.0 schema must require registerComments without migration defaults");

  606. 

  607.     QJsonObject missing_rung_comment = QJsonDocument::fromJson(saved_json).object();

  608.     QJsonArray missing_comment_logics = missing_rung_comment.value(

  609.         QStringLiteral("controlLogics")).toArray();

  610.     QJsonObject first_logic = missing_comment_logics.at(0).toObject();

  611.     QJsonArray first_rungs = first_logic.value(QStringLiteral("rungs")).toArray();

  612.     QJsonObject first_rung = first_rungs.at(0).toObject();

  613.     first_rung.remove(QStringLiteral("comment"));

  614.     first_rungs.replace(0, first_rung);

  615.     first_logic.insert(QStringLiteral("rungs"), first_rungs);

  616.     missing_comment_logics.replace(0, first_logic);

  617.     missing_rung_comment.insert(QStringLiteral("controlLogics"), missing_comment_logics);

  618.     writeText(

  619.         missing_rung_comment_path,

  620.         QJsonDocument(missing_rung_comment).toJson(QJsonDocument::Compact));

  621.     missing_result = service.load(missing_rung_comment_path.toStdString());

  622.     require(!missing_result.succeeded

  623.                 && missing_result.storageError == ProjectStorageError::MissingField,

  624.             "the 1.0 schema must require rung comments without migration defaults");

  625. 

  626.     QJsonObject missing_target = QJsonDocument::fromJson(saved_json).object();

  627.     QJsonArray pages = missing_target.value(QStringLiteral("hmiPages")).toArray();

  628.     QJsonObject main_page = pages.at(0).toObject();

  629.     QJsonArray controls = main_page.value(QStringLiteral("controls")).toArray();

  630.     QJsonObject jump = controls.at(5).toObject();

  631.     jump.remove(QStringLiteral("targetPageId"));

  632.     controls.replace(5, jump);

  633.     main_page.insert(QStringLiteral("controls"), controls);

  634.     pages.replace(0, main_page);

  635.     missing_target.insert(QStringLiteral("hmiPages"), pages);

  636.     writeText(

  637.         missing_target_path,

  638.         QJsonDocument(missing_target).toJson(QJsonDocument::Compact));

  639.     missing_result = service.load(missing_target_path.toStdString());

  640.     require(!missing_result.succeeded

  641.                 && missing_result.storageError == ProjectStorageError::MissingField,

  642.             "the 1.0 schema must require PageJump targetPageId");

  643. 

  644.     QJsonObject missing_progress_range = QJsonDocument::fromJson(saved_json).object();

  645.     pages = missing_progress_range.value(QStringLiteral("hmiPages")).toArray();

  646.     main_page = pages.at(0).toObject();

  647.     controls = main_page.value(QStringLiteral("controls")).toArray();

  648.     QJsonObject progress = controls.at(7).toObject();

  649.     progress.remove(QStringLiteral("maximumValue"));

  650.     controls.replace(7, progress);

  651.     main_page.insert(QStringLiteral("controls"), controls);

  652.     pages.replace(0, main_page);

  653.     missing_progress_range.insert(QStringLiteral("hmiPages"), pages);

  654.     writeText(

  655.         missing_progress_range_path,

  656.         QJsonDocument(missing_progress_range).toJson(QJsonDocument::Compact));

  657.     missing_result = service.load(missing_progress_range_path.toStdString());

  658.     require(!missing_result.succeeded

  659.                 && missing_result.storageError == ProjectStorageError::MissingField,

  660.             "the 1.0 schema must require the ProgressBar value range");

  661. }

  662. 

  663. void testInvalidFiles()

  664. {

  665.     // 非法文件必须被拒绝，并且不得覆盖服务中当前工程

  666.     QTemporaryDir directory;

  667.     require(directory.isValid(), "temporary directory must be valid");

  668. 

  669.     JsonProjectStorage storage;

  670.     ProjectService service(storage);

  671.     service.editProject().metadata.name = "Current project";

  672.     const QString invalid_json = directory.filePath("invalid-json.json");

  673.     const QString missing_field = directory.filePath("missing-field.json");

  674.     const QString unsupported_version = directory.filePath("unsupported-version.json");

  675. 

  676.     writeText(invalid_json, "{");

  677.     auto result = service.load(invalid_json.toStdString());

  678.     require(!result.succeeded

  679.                 && result.storageError == ProjectStorageError::InvalidJson,

  680.             "invalid JSON must be rejected");

  681.     require(service.project().metadata.name == "Current project",

  682.             "invalid load must keep current project");

  683. 

  684.     writeText(missing_field, R"({"formatVersion":"1.0"})");

  685.     result = service.load(missing_field.toStdString());

  686.     require(!result.succeeded

  687.                 && result.storageError == ProjectStorageError::MissingField,

  688.             "missing fields must be rejected");

  689. 

  690.     writeText(unsupported_version, R"({"formatVersion":"2.0"})");

  691.     result = service.load(unsupported_version.toStdString());

  692.     require(!result.succeeded

  693.                 && result.storageError == ProjectStorageError::UnsupportedVersion,

  694.             "unsupported versions must be rejected");

  695. }

  696. 

  697. void testServiceStateAndSaveErrors()

  698. {

  699.     // 保存路径和修改标记只在成功持久化后更新

  700.     QTemporaryDir directory;

  701.     require(directory.isValid(), "temporary directory must be valid");

  702. 

  703.     JsonProjectStorage storage;

  704.     ProjectService service(storage);

  705.     require(service.save().error == ProjectServiceError::FilePathRequired,

  706.             "save without a current path must be rejected");

  707.     require(service.createNewProject("   ").error

  708.                 == ProjectServiceError::InvalidProjectName,

  709.             "blank project names must be rejected");

  710. 

  711.     const QString path = directory.filePath("state.json");

  712.     service.editProject().metadata.name = "State project";

  713.     require(service.saveAs(path.toStdString()).succeeded,

  714.             "state project save must succeed");

  715.     service.editProject().metadata.name = "Changed project";

  716.     require(service.isModified(), "editing the project must mark it modified");

  717.     require(service.save().succeeded, "save must use the current file path");

  718.     require(!service.isModified(), "successful save must clear modified state");

  719. 

  720.     const QString failed_path = directory.filePath("missing/subdir/state.json");

  721.     require(!service.saveAs(failed_path.toStdString()).succeeded,

  722.             "save to an unavailable path must fail");

  723.     require(service.currentFilePath() == path.toStdString(),

  724.             "failed save as must keep the previous current path");

  725. }

  726. 

  727. void testRegisterCommentService()

  728. {

  729.     JsonProjectStorage storage;

  730.     ProjectService project_service(storage);

  731.     RegisterCommentService service(project_service);

  732. 

  733.     require(service.setComment(

  734.                 RegisterAddress{RegisterArea::D, 3}, "  目标温度  ").succeeded,

  735.             "register comment service must create a trimmed D comment");

  736.     require(service.setComment(

  737.                 RegisterAddress{RegisterArea::M, 2}, "启动信号").succeeded,

  738.             "register comment service must create an M comment");

  739.     require(service.comments().size() == 2U

  740.                 && service.comments().front().address.area() == RegisterArea::M

  741.                 && service.comments().front().address.index() == 2

  742.                 && service.comments().back().text == "目标温度",

  743.             "register comments must be sorted by area and address");

  744.     require(service.setComment(

  745.                 RegisterAddress{RegisterArea::M, 2}, "新的启动信号").succeeded

  746.                 && service.comments().size() == 2U

  747.                 && service.findComment(RegisterAddress{RegisterArea::M, 2})->text

  748.                     == "新的启动信号",

  749.             "setting an existing address must update instead of duplicating it");

  750.     require(!service.setComment(RegisterAddress{RegisterArea::M, 4}, " \t").succeeded,

  751.             "blank register comments must be rejected by the service");

  752.     require(service.removeComment(RegisterAddress{RegisterArea::M, 2}).succeeded

  753.                 && service.findComment(RegisterAddress{RegisterArea::M, 2}) == nullptr,

  754.             "register comments must be removable");

  755.     require(!service.removeComment(RegisterAddress{RegisterArea::M, 2}).succeeded,

  756.             "removing a missing register comment must fail explicitly");

  757. }

  758. 

  759. } // namespace

  760. 

  761. int main()

  762. {

  763.     try

  764.     {

  765.         // 工程服务和 JSON 存储在同一测试进程中验证完整闭环

  766.         testEmptyProjectRoundTrip();

  767.         testExampleProjectRoundTrip();

  768.         testRegisterCommentService();

  769.         testInvalidFiles();

  770.         testServiceStateAndSaveErrors();

  771.     }

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

  773.     {

  774.         std::cerr << "project management tests failed: " << error.what() << '\n';

  775.         return 1;

  776.     }

  777. 

  778.     std::cout << "project management tests passed\n";

  779.     return 0;

  780. }