suyu
/
suyu_two
1
0
Forkuj 0
Kod Zgłoszenia 0 Oczekujące zmiany 0 Wydania 0 Wiki Aktywność
综合平台编程器项目的远程存储
Nie możesz wybrać więcej, niż 25 tematów Tematy muszą się zaczynać od litery lub cyfry, mogą zawierać myślniki ('-') i mogą mieć do 35 znaków.
110 Commity
1 Gałąź
183 MiB
 
 
 
 
Drzewo: 66ce714bf9
Gałęzie Tagi
${ item.name }
Utwórz gałąź ${ searchTerm }
z '66ce714bf9'
${ noResults }
suyu_two/app/tests/project_management_tests.cpp

954 wiersze
43 KiB
Czysty Wina Historia 

  1. #include "domain/project_storage.h"

  2. #include "domain/hmi_model.h"

  3. #include "infrastructure/json_project_storage.h"

  4. #include "support/test_support.h"

  5. #include "services/register_comment_service.h"

  6. #include "services/project_service.h"

  7. #include "domain/project_limits.h"

  8. 

  9. #include <QFile>

  10. #include <QJsonArray>

  11. #include <QJsonDocument>

  12. #include <QJsonObject>

  13. #include <QTemporaryDir>

  14. 

  15. #include <exception>

  16. #include <iostream>

  17. #include <stdexcept>

  18. #include <string>

  19. #include <utility>

  20. 

  21. namespace {

  22. 

  23. using TestSupport::require;

  24. 

  25. Project makeExampleProject()

  26. {

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

  28.     HmiControl start_button;

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

  30.     start_button.type = HmiControlType::Button;

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

  32.     start_button.text = "Start";

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

  34.     start_button.buttonOperation = HmiButtonOperation::SetOn;

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

  36.     start_button.properties.emplace(HmiAppearanceProperty::kTextColor, "#E53935");

  37.     start_button.properties.emplace(HmiAppearanceProperty::kFontSize, "18");

  38.     start_button.properties.emplace(HmiAppearanceProperty::kFontBold, "true");

  39.     start_button.properties.emplace(HmiAppearanceProperty::kFontItalic, "false");

  40. 

  41.     HmiControl running_indicator;

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

  43.     running_indicator.type = HmiControlType::Indicator;

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

  45.     running_indicator.text = "Running";

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

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

  48. 

  49.     HmiControl temperature_display;

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

  51.     temperature_display.type = HmiControlType::NumericDisplay;

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

  53.     temperature_display.text = "Temperature";

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

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

  56. 

  57.     HmiControl target_input;

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

  59.     target_input.type = HmiControlType::NumericInput;

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

  61.     target_input.text = "Target";

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

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

  64. 

  65.     HmiControl title_label;

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

  67.     title_label.type = HmiControlType::Label;

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

  69.     title_label.text = "Production line";

  70. 

  71.     HmiControl settings_jump;

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

  73.     settings_jump.type = HmiControlType::PageJump;

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

  75.     settings_jump.text = "Settings";

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

  77. 

  78.     HmiControl alarm_list;

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

  80.     alarm_list.type = HmiControlType::AlarmList;

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

  82.     alarm_list.text = "Alarms";

  83. 

  84.     HmiControl progress_bar;

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

  86.     progress_bar.type = HmiControlType::ProgressBar;

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

  88.     progress_bar.text = "Completion";

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

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

  91. 

  92.     HmiPage page;

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

  94.     page.name = "Main";

  95.     page.controls.push_back(start_button);

  96.     page.controls.push_back(running_indicator);

  97.     page.controls.push_back(temperature_display);

  98.     page.controls.push_back(target_input);

  99.     page.controls.push_back(title_label);

  100.     page.controls.push_back(settings_jump);

  101.     page.controls.push_back(alarm_list);

  102.     page.controls.push_back(progress_bar);

  103. 

  104.     HmiPage settings_page;

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

  106.     settings_page.name = "Settings";

  107. 

  108.     LogicNode contact;

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

  110.     contact.config = ContactNodeConfig{

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

  112.         ContactMode::NormallyOpen};

  113. 

  114.     LogicNode compare;

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

  116.     compare.config = CompareNodeConfig{

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

  118.         ComparisonOperator::GreaterThanOrEqual,

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

  120. 

  121.     LogicNode hold_contact;

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

  123.     hold_contact.config = ContactNodeConfig{

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

  125.         ContactMode::NormallyOpen};

  126. 

  127.     LogicNode coil;

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

  129.     coil.config = CoilNodeConfig{

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

  131.         CoilMode::Set};

  132. 

  133.     ControlLogic logic;

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

  135.     logic.name = "Start logic";

  136.     logic.enabled = false;

  137.     LadderRung rung;

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

  139.     rung.name = "Network 1";

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

  141.     ConditionExpression parallel;

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

  143.     parallel.kind = ConditionExpressionKind::Parallel;

  144.     parallel.children = {

  145.         ConditionExpression::fromNode(contact),

  146.         ConditionExpression::fromNode(hold_contact)};

  147.     ConditionExpression series;

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

  149.     series.kind = ConditionExpressionKind::Series;

  150.     series.children = {

  151.         std::move(parallel),

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

  153.         ConditionExpression::fromNode(compare)};

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

  155.     rung.output = coil;

  156.     logic.rungs.push_back(rung);

  157. 

  158.     LogicNode rising_edge;

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

  160.     rising_edge.config = EdgeContactNodeConfig{

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

  162.     LogicNode edge_output;

  163.     edge_output.id = "edge-output";

  164.     edge_output.config = CoilNodeConfig{

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

  166.     LadderRung edge_rung;

  167.     edge_rung.id = "edge-rung";

  168.     edge_rung.name = "Edge network";

  169.     edge_rung.comment = "上升沿输出";

  170.     edge_rung.condition = ConditionExpression::fromNode(rising_edge);

  171.     edge_rung.output = edge_output;

  172.     logic.rungs.push_back(edge_rung);

  173. 

  174.     const auto addDataRung = [&logic](

  175.         const std::string &rung_id,

  176.         const std::string &input_id,

  177.         int input_address,

  178.         LogicNode output)

  179.     {

  180.         LogicNode input;

  181.         input.id = input_id;

  182.         input.config = ContactNodeConfig{

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

  184.             ContactMode::NormallyOpen};

  185.         LadderRung data_rung;

  186.         data_rung.id = rung_id;

  187.         data_rung.name = rung_id;

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

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

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

  191.     };

  192.     addDataRung(

  193.         "move-rung",

  194.         "move-input",

  195.         20,

  196.         LogicNode{

  197.             "move-output",

  198.             MoveNodeConfig{

  199.                 WordOperand{

  200.                     WordOperandKind::Constant,

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

  202.                     25},

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

  204.             true});

  205.     addDataRung(

  206.         "add-rung",

  207.         "add-input",

  208.         21,

  209.         LogicNode{

  210.             "add-output",

  211.             ArithmeticNodeConfig{

  212.                 ArithmeticOperation::Add,

  213.                 WordOperand{

  214.                     WordOperandKind::Register,

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

  216.                     0},

  217.                 WordOperand{

  218.                     WordOperandKind::Constant,

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

  220.                     1},

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

  222.             true});

  223.     addDataRung(

  224.         "sub-rung",

  225.         "sub-input",

  226.         22,

  227.         LogicNode{

  228.             "sub-output",

  229.             ArithmeticNodeConfig{

  230.                 ArithmeticOperation::Subtract,

  231.                 WordOperand{

  232.                     WordOperandKind::Register,

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

  234.                     0},

  235.                 WordOperand{

  236.                     WordOperandKind::Constant,

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

  238.                     1},

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

  240.             true});

  241. 

  242.     Project project;

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

  244.     project.hmiPages.push_back(page);

  245.     project.hmiPages.push_back(settings_page);

  246.     project.initialHmiPageId = page.id;

  247.     project.alarmDefinitions.push_back(

  248.         {"alarm-emergency",

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

  250.          AlarmCondition::MOn,

  251.          0,

  252.          "Emergency stop"});

  253.     project.alarmDefinitions.push_back(

  254.         {"alarm-temperature",

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

  256.          AlarmCondition::DHigh,

  257.          80,

  258.          "Temperature high"});

  259.     project.registerComments = {

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

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

  262.     project.controlLogics.push_back(logic);

  263.     ControlLogic draft_logic;

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

  265.     draft_logic.name = "Draft logic";

  266.     draft_logic.enabled = false;

  267.     draft_logic.rungs.push_back(

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

  269.     project.controlLogics.push_back(draft_logic);

  270.     return project;

  271. }

  272. 

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

  274. {

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

  276.     QFile file(path);

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

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

  279. }

  280. 

  281. QByteArray readBytes(const QString &path)

  282. {

  283.     QFile file(path);

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

  285.     return file.readAll();

  286. }

  287. 

  288. void testEmptyProjectRoundTrip()

  289. {

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

  291.     QTemporaryDir directory;

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

  293. 

  294.     JsonProjectStorage storage;

  295.     ProjectService service(storage);

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

  297.             "empty project creation must succeed");

  298. 

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

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

  301.             "empty project save must succeed");

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

  303. 

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

  305.             "empty project load must succeed");

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

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

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

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

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

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

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

  313. }

  314. 

  315. void testUnconditionalOutputRoundTrip()

  316. {

  317.     QTemporaryDir directory;

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

  319. 

  320.     JsonProjectStorage storage;

  321.     ProjectService service(storage);

  322.     require(service.createNewProject("Unconditional output").succeeded,

  323.             "unconditional output project creation must succeed");

  324.     LadderRung rung;

  325.     rung.id = "unconditional-rung";

  326.     rung.name = "Unconditional rung";

  327.     LogicNode coil;

  328.     coil.id = "unconditional-coil";

  329.     coil.config = CoilNodeConfig{

  330.         RegisterAddress{RegisterArea::M, 10}, CoilMode::Normal};

  331.     rung.output = coil;

  332.     service.editProject().controlLogics.push_back(

  333.         ControlLogic{"logic-1", "Logic 1", {rung}, true});

  334.     require(service.project().validateForRunning(),

  335.             "an output-only project must be runnable before saving");

  336. 

  337.     const QString path = directory.filePath("unconditional-output.json");

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

  339.             "an output-only project must save successfully");

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

  341.             "an output-only project must load successfully");

  342.     const LadderRung &loaded = service.project().controlLogics.front().rungs.front();

  343.     require(!loaded.condition.has_value() && loaded.output.has_value()

  344.                 && loaded.validateForRunning(),

  345.             "JSON round trip must preserve unconditional output semantics");

  346. }

  347. 

  348. void testExampleProjectRoundTrip()

  349. {

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

  351.     QTemporaryDir directory;

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

  353. 

  354.     JsonProjectStorage storage;

  355.     ProjectService service(storage);

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

  357. 

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

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

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

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

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

  363.     const QString missing_progress_range_path = directory.filePath(

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

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

  366.     const QString missing_register_comments_path = directory.filePath(

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

  368.     const QString missing_rung_comment_path = directory.filePath(

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

  370.     const QString multiline_register_comment_path = directory.filePath(

  371.         "multiline-register-comment.json");

  372.     const QString multiline_rung_comment_path = directory.filePath(

  373.         "multiline-rung-comment.json");

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

  375.             "example project save must succeed");

  376.     const QByteArray saved_json = readBytes(first_path);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  410.             "example project load must succeed");

  411. 

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

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

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

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

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

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

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

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

  420.                 == RegisterArea::M,

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

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

  423.                 == HmiButtonOperation::SetOn,

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

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

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

  427.     require(project.hmiPages.front().controls.front().properties.at(

  428.                 HmiAppearanceProperty::kTextColor) == "#E53935"

  429.                 && project.hmiPages.front().controls.front().properties.at(

  430.                     HmiAppearanceProperty::kFontSize) == "18"

  431.                 && project.hmiPages.front().controls.front().properties.at(

  432.                     HmiAppearanceProperty::kFontBold) == "true"

  433.                 && project.hmiPages.front().controls.front().properties.at(

  434.                     HmiAppearanceProperty::kFontItalic) == "false",

  435.             "HMI appearance properties must survive round trip");

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

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

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

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

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

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

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

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

  444.                     == "settings-page",

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

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

  447.                 == HmiControlType::AlarmList,

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

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

  450.                 == HmiControlType::ProgressBar

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

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

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

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

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

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

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

  458.                     == AlarmCondition::MOn

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  473.     require(rung.condition.has_value()

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

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

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

  477.                 == ConditionExpressionKind::Parallel

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

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

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

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

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

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

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

  485. 

  486.     const LadderRung &edge_rung = project.controlLogics.front().rungs.at(1);

  487.     require(edge_rung.output.has_value()

  488.                 && std::holds_alternative<CoilNodeConfig>(edge_rung.output->config)

  489.                 && std::get<CoilNodeConfig>(edge_rung.output->config).address

  490.                     == RegisterAddress{RegisterArea::M, 6},

  491.             "edge network output must survive round trip");

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

  493.                 edge_rung.condition->node->config)

  494.                 && std::get<EdgeContactNodeConfig>(edge_rung.condition->node->config).mode

  495.                     == EdgeMode::Rising,

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

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

  498.                 project.controlLogics.front().rungs.at(2).output->config)

  499.                 .source.constant == 25,

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

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

  502.                 project.controlLogics.front().rungs.at(3).output->config)

  503.                 .operation == ArithmeticOperation::Add

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

  505.                     project.controlLogics.front().rungs.at(4).output->config)

  506.                     .operation == ArithmeticOperation::Subtract,

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

  508. 

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

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

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

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

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

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

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

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

  517. 

  518.     QByteArray invalid_operation = saved_json;

  519.     invalid_operation.replace(

  520.         "\"buttonOperation\": \"setOn\"",

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

  522.     writeText(invalid_operation_path, invalid_operation);

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

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

  525. 

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

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

  528.     writeText(

  529.         missing_initial_path,

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

  531.     ProjectOperationResult missing_result = service.load(

  532.         missing_initial_path.toStdString());

  533.     require(!missing_result.succeeded

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

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

  536. 

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

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

  539.     writeText(

  540.         missing_alarms_path,

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

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

  543.     require(!missing_result.succeeded

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

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

  546. 

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

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

  549.     writeText(

  550.         missing_register_comments_path,

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

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

  553.     require(!missing_result.succeeded

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

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

  556. 

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

  558.     QJsonArray missing_comment_logics = missing_rung_comment.value(

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

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

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

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

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

  564.     first_rungs.replace(0, first_rung);

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

  566.     missing_comment_logics.replace(0, first_logic);

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

  568.     writeText(

  569.         missing_rung_comment_path,

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

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

  572.     require(!missing_result.succeeded

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

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

  575. 

  576.     QJsonObject multiline_register_comment = QJsonDocument::fromJson(

  577.         saved_json).object();

  578.     QJsonArray comments = multiline_register_comment.value(

  579.         QStringLiteral("registerComments")).toArray();

  580.     QJsonObject first_comment = comments.at(0).toObject();

  581.     first_comment.insert(QStringLiteral("text"), QStringLiteral("第一行\n第二行"));

  582.     comments.replace(0, first_comment);

  583.     multiline_register_comment.insert(QStringLiteral("registerComments"), comments);

  584.     writeText(

  585.         multiline_register_comment_path,

  586.         QJsonDocument(multiline_register_comment).toJson(QJsonDocument::Compact));

  587.     missing_result = service.load(multiline_register_comment_path.toStdString());

  588.     require(!missing_result.succeeded

  589.                 && missing_result.storageError == ProjectStorageError::InvalidProject,

  590.             "JSON loading must reject multiline register comments");

  591. 

  592.     QJsonObject multiline_rung_comment = QJsonDocument::fromJson(saved_json).object();

  593.     QJsonArray multiline_logics = multiline_rung_comment.value(

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

  595.     first_logic = multiline_logics.at(0).toObject();

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

  597.     first_rung = first_rungs.at(0).toObject();

  598.     first_rung.insert(QStringLiteral("comment"), QStringLiteral("第一行\n第二行"));

  599.     first_rungs.replace(0, first_rung);

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

  601.     multiline_logics.replace(0, first_logic);

  602.     multiline_rung_comment.insert(QStringLiteral("controlLogics"), multiline_logics);

  603.     writeText(

  604.         multiline_rung_comment_path,

  605.         QJsonDocument(multiline_rung_comment).toJson(QJsonDocument::Compact));

  606.     missing_result = service.load(multiline_rung_comment_path.toStdString());

  607.     require(!missing_result.succeeded

  608.                 && missing_result.storageError == ProjectStorageError::InvalidProject,

  609.             "JSON loading must reject multiline rung comments");

  610. 

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

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

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

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

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

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

  617.     controls.replace(5, jump);

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

  619.     pages.replace(0, main_page);

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

  621.     writeText(

  622.         missing_target_path,

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

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

  625.     require(!missing_result.succeeded

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

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

  628. 

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

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

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

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

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

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

  635.     controls.replace(7, progress);

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

  637.     pages.replace(0, main_page);

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

  639.     writeText(

  640.         missing_progress_range_path,

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

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

  643.     require(!missing_result.succeeded

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

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

  646. }

  647. 

  648. void testInvalidFiles()

  649. {

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

  651.     QTemporaryDir directory;

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

  653. 

  654.     JsonProjectStorage storage;

  655.     ProjectService service(storage);

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

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

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

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

  660. 

  661.     writeText(invalid_json, "{");

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

  663.     require(!result.succeeded

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

  665.             "invalid JSON must be rejected");

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

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

  668. 

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

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

  671.     require(!result.succeeded

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

  673.             "missing fields must be rejected");

  674. 

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

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

  677.     require(!result.succeeded

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

  679.             "unsupported versions must be rejected");

  680. }

  681. 

  682. void testQuantityFileLimits()

  683. {

  684.     QTemporaryDir directory;

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

  686. 

  687.     JsonProjectStorage storage;

  688.     ProjectService service(storage);

  689.     require(service.createNewProject("Quantity limits").succeeded,

  690.             "the quantity-limit fixture project must be created");

  691. 

  692.     const QString oversized_path = directory.filePath("oversized.json");

  693.     const QByteArray oversized(

  694.         static_cast<int>(ProjectLimits::kMaximumProjectFileBytes + 1U), ' ');

  695.     writeText(oversized_path, oversized);

  696.     const ProjectLoadResult oversized_result =

  697.         storage.load(oversized_path.toStdString());

  698.     require(!oversized_result.succeeded

  699.                 && oversized_result.error == ProjectStorageError::InvalidJson,

  700.             "a JSON file over 16 MiB must be rejected before parsing");

  701. 

  702.     const QString valid_path = directory.filePath("fixture.json");

  703.     require(service.saveAs(valid_path.toStdString()).succeeded,

  704.             "the quantity-limit fixture must be saved");

  705.     QJsonObject root = QJsonDocument::fromJson(readBytes(valid_path)).object();

  706.     QJsonArray too_many_pages;

  707.     for (int index = 0;

  708.          index <= static_cast<int>(ProjectLimits::kMaximumHmiPages);

  709.          ++index)

  710.     {

  711.         too_many_pages.append(QJsonObject{});

  712.     }

  713.     root.insert(QStringLiteral("hmiPages"), too_many_pages);

  714.     const QString too_many_pages_path = directory.filePath("too-many-pages.json");

  715.     writeText(

  716.         too_many_pages_path,

  717.         QJsonDocument(root).toJson(QJsonDocument::Compact));

  718.     const ProjectLoadResult too_many_pages_result =

  719.         storage.load(too_many_pages_path.toStdString());

  720.     require(!too_many_pages_result.succeeded

  721.                 && too_many_pages_result.error == ProjectStorageError::InvalidField,

  722.             "a JSON page array over the configured limit must be rejected");

  723. 

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

  725.     require(service.saveAs(valid_path.toStdString()).succeeded,

  726.             "the nested-expression fixture must be saved");

  727.     root = QJsonDocument::fromJson(readBytes(valid_path)).object();

  728.     QJsonArray logics = root.value(QStringLiteral("controlLogics")).toArray();

  729.     QJsonObject logic = logics.at(0).toObject();

  730.     QJsonArray rungs = logic.value(QStringLiteral("rungs")).toArray();

  731.     QJsonObject rung = rungs.at(0).toObject();

  732.     QJsonObject leaf = rung.value(QStringLiteral("condition")).toObject();

  733.     while (leaf.value(QStringLiteral("kind")).toString() != QStringLiteral("node"))

  734.     {

  735.         leaf = leaf.value(QStringLiteral("children")).toArray().at(0).toObject();

  736.     }

  737.     QJsonObject nested = leaf;

  738.     for (int depth = 1;

  739.          depth <= static_cast<int>(ProjectLimits::kMaximumExpressionDepth) + 1;

  740.          ++depth)

  741.     {

  742.         QJsonObject sibling = leaf;

  743.         sibling.insert(

  744.             QStringLiteral("id"),

  745.             QStringLiteral("json-depth-sibling-") + QString::number(depth));

  746.         QJsonArray children;

  747.         children.append(nested);

  748.         children.append(sibling);

  749.         QJsonObject parent;

  750.         parent.insert(

  751.             QStringLiteral("id"),

  752.             QStringLiteral("json-depth-") + QString::number(depth));

  753.         parent.insert(

  754.             QStringLiteral("kind"),

  755.             depth % 2 == 0 ? QStringLiteral("parallel") : QStringLiteral("series"));

  756.         parent.insert(QStringLiteral("children"), children);

  757.         nested = parent;

  758.     }

  759.     rung.insert(QStringLiteral("condition"), nested);

  760.     rungs[0] = rung;

  761.     logic.insert(QStringLiteral("rungs"), rungs);

  762.     logics[0] = logic;

  763.     root.insert(QStringLiteral("controlLogics"), logics);

  764.     const QString deep_path = directory.filePath("too-deep.json");

  765.     writeText(deep_path, QJsonDocument(root).toJson(QJsonDocument::Compact));

  766.     const ProjectLoadResult deep_result = storage.load(deep_path.toStdString());

  767.     require(!deep_result.succeeded

  768.                 && deep_result.error == ProjectStorageError::InvalidField,

  769.             "a condition expression deeper than the configured limit must be rejected while parsing");

  770. }

  771. 

  772. void testHmiPageJsonBoundaries()

  773. {

  774.     // JSON 入口必须和页面领域校验使用同一组业务边界

  775.     QTemporaryDir directory;

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

  777. 

  778.     JsonProjectStorage storage;

  779.     ProjectService service(storage);

  780.     Project boundary_project = makeExampleProject();

  781.     boundary_project.hmiPages.front().controls.clear();

  782.     service.editProject() = std::move(boundary_project);

  783. 

  784.     const QString fixture_path = directory.filePath("hmi-page-boundary-fixture.json");

  785.     require(service.saveAs(fixture_path.toStdString()).succeeded,

  786.             "the HMI boundary fixture must be saved");

  787. 

  788.     const QJsonObject original_root =

  789.         QJsonDocument::fromJson(readBytes(fixture_path)).object();

  790. 

  791.     const auto loadWithSize = [&](int width, int height, const QString &name)

  792.     {

  793.         QJsonObject root = original_root;

  794.         QJsonArray pages = root.value(QStringLiteral("hmiPages")).toArray();

  795.         QJsonObject page = pages.at(0).toObject();

  796.         page.insert(QStringLiteral("width"), width);

  797.         page.insert(QStringLiteral("height"), height);

  798.         pages.replace(0, page);

  799.         root.insert(QStringLiteral("hmiPages"), pages);

  800. 

  801.         const QString path = directory.filePath(name);

  802.         writeText(path, QJsonDocument(root).toJson(QJsonDocument::Compact));

  803.         return storage.load(path.toStdString());

  804.     };

  805. 

  806.     require(!loadWithSize(

  807.                  ProjectLimits::kMinimumHmiPageWidth - 1,

  808.                  ProjectLimits::kDefaultHmiPageHeight,

  809.                  QStringLiteral("width-below-minimum.json"))

  810.                  .succeeded,

  811.             "JSON must reject an HMI page width below 320");

  812.     require(!loadWithSize(

  813.                  ProjectLimits::kMaximumHmiPageWidth + 1,

  814.                  ProjectLimits::kDefaultHmiPageHeight,

  815.                  QStringLiteral("width-above-maximum.json"))

  816.                  .succeeded,

  817.             "JSON must reject an HMI page width above 1600");

  818.     require(!loadWithSize(

  819.                  ProjectLimits::kDefaultHmiPageWidth,

  820.                  ProjectLimits::kMinimumHmiPageHeight - 1,

  821.                  QStringLiteral("height-below-minimum.json"))

  822.                  .succeeded,

  823.             "JSON must reject an HMI page height below 200");

  824.     require(!loadWithSize(

  825.                  ProjectLimits::kDefaultHmiPageWidth,

  826.                  ProjectLimits::kMaximumHmiPageHeight + 1,

  827.                  QStringLiteral("height-above-maximum.json"))

  828.                  .succeeded,

  829.             "JSON must reject an HMI page height above 800");

  830. 

  831.     const ProjectLoadResult minimum_result = loadWithSize(

  832.         ProjectLimits::kMinimumHmiPageWidth,

  833.         ProjectLimits::kMinimumHmiPageHeight,

  834.         QStringLiteral("minimum-size.json"));

  835.     require(minimum_result.succeeded

  836.                 && minimum_result.project.hmiPages.front().width

  837.                     == ProjectLimits::kMinimumHmiPageWidth

  838.                 && minimum_result.project.hmiPages.front().height

  839.                     == ProjectLimits::kMinimumHmiPageHeight,

  840.             "JSON must accept the minimum HMI page size 320x200");

  841. 

  842.     const ProjectLoadResult maximum_result = loadWithSize(

  843.         ProjectLimits::kMaximumHmiPageWidth,

  844.         ProjectLimits::kMaximumHmiPageHeight,

  845.         QStringLiteral("maximum-size.json"));

  846.     require(maximum_result.succeeded

  847.                 && maximum_result.project.hmiPages.front().width

  848.                     == ProjectLimits::kMaximumHmiPageWidth

  849.                 && maximum_result.project.hmiPages.front().height

  850.                     == ProjectLimits::kMaximumHmiPageHeight,

  851.             "JSON must accept the maximum HMI page size 1600x800");

  852. }

  853. 

  854. void testServiceStateAndSaveErrors()

  855. {

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

  857.     QTemporaryDir directory;

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

  859. 

  860.     JsonProjectStorage storage;

  861.     ProjectService service(storage);

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

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

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

  865.                 == ProjectServiceError::InvalidProjectName,

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

  867. 

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

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

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

  871.             "state project save must succeed");

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

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

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

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

  876. 

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

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

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

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

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

  882. }

  883. 

  884. void testRegisterCommentService()

  885. {

  886.     JsonProjectStorage storage;

  887.     ProjectService project_service(storage);

  888.     RegisterCommentService service(project_service);

  889. 

  890.     require(service.setComment(

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

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

  893.     require(service.setComment(

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

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

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

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

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

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

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

  901.     require(service.setComment(

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

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

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

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

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

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

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

  909.     require(service.setComment(

  910.                 RegisterAddress{RegisterArea::M, 4},

  911.                 std::string(ProjectLimits::kMaximumRegisterCommentBytes, 'a'))

  912.                 .succeeded,

  913.             "a register comment at the byte limit must be accepted");

  914.     require(!service.setComment(

  915.                 RegisterAddress{RegisterArea::M, 5},

  916.                 std::string(ProjectLimits::kMaximumRegisterCommentBytes + 1U, 'a'))

  917.                  .succeeded,

  918.             "an oversized register comment must be rejected by the service");

  919.     require(!service.setComment(

  920.                 RegisterAddress{RegisterArea::M, 5}, "第一行\n第二行").succeeded,

  921.             "a multiline register comment must be rejected by the service");

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

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

  924.             "register comments must be removable");

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

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

  927. }

  928. 

  929. } // namespace

  930. 

  931. int main()

  932. {

  933.     try

  934.     {

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

  936.         testEmptyProjectRoundTrip();

  937.         testUnconditionalOutputRoundTrip();

  938.         testExampleProjectRoundTrip();

  939.         testRegisterCommentService();

  940.         testInvalidFiles();

  941.         testQuantityFileLimits();

  942.         testHmiPageJsonBoundaries();

  943.         testServiceStateAndSaveErrors();

  944.     }

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

  946.     {

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

  948.         return 1;

  949.     }

  950. 

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

  952.     return 0;

  953. }