suyu
/
suyu_two
1
0
Форкнуть 0
Код Задачи 0 Pull Request'ы 0 Релизы 0 Вики Активность
综合平台编程器项目的远程存储
Вы не можете выбрать более 25 тем Темы должны начинаться с буквы или цифры, могут содержать дефисы(-) и должны содержать не более 35 символов.
161 коммит
1 ветка
183 MiB
 
 
 
 
Дерево: f220912a1e
Ветки Теги
${ item.name }
Создать ветку ${ searchTerm }
из 'f220912a1e'
${ noResults }
suyu_two/app/tests/register_monitor_service_te...

355 строки
18 KiB
Исходник Вина История 

  1. #include "domain/active_register_repository.h"

  2. #include "domain/register_monitor_model.h"

  3. #include "domain/register_repository.h"

  4. #include "domain/virtual_register_repository.h"

  5. #include "services/register_monitor_service.h"

  6. #include "support/test_support.h"

  7. 

  8. #include <iostream>

  9. #include <cmath>

  10. #include <limits>

  11. #include <stdexcept>

  12. #include <string>

  13. #include <variant>

  14. 

  15. namespace {

  16. 

  17. using TestSupport::require;

  18. 

  19. void testRangeManagement()

  20. {

  21.     VirtualRegisterRepository repository;

  22.     RegisterMonitorService service(repository);

  23.     int change_count = 0;

  24.     service.setAddressesChangedCallback([&change_count] { ++change_count; });

  25. 

  26.     const RegisterMonitorResult added = service.addRange(" d10 ", 3);

  27.     require(added.succeeded && added.affectedCount == 3

  28.                 && service.addresses().size() == 3U,

  29.             "monitor service must expand a normalized continuous address range");

  30.     require(service.addresses().front() == RegisterAddress{RegisterArea::D, 10}

  31.                 && service.addresses().back() == RegisterAddress{RegisterArea::D, 12},

  32.             "monitor service must preserve expanded address order");

  33.     const RegisterMonitorResult duplicate = service.addRange("D11", 2);

  34.     require(!duplicate.succeeded && duplicate.error == RegisterMonitorError::NoChange,

  35.             "monitor service must reject a fully duplicated range");

  36.     require(!service.addRange("M4000", 2).succeeded,

  37.             "monitor service must reject a range crossing address 4000");

  38.     require(change_count == 1,

  39.             "failed additions must not report a monitor address change");

  40. 

  41.     require(service.remove({RegisterAddress{RegisterArea::D, 11}}).succeeded

  42.                 && service.addresses().size() == 2U,

  43.             "monitor service must remove selected addresses");

  44.     require(service.clear().succeeded && service.addresses().empty(),

  45.             "monitor service must clear the current monitor table");

  46.     require(change_count == 3,

  47.             "successful add, remove and clear operations must notify address changes");

  48. }

  49. 

  50. void testSharedActiveRepositoryValues()

  51. {

  52.     VirtualRegisterRepository virtual_repository;

  53.     VirtualRegisterRepository plc_repository;

  54.     ActiveRegisterRepository active_repository(virtual_repository);

  55.     RegisterMonitorService service(active_repository);

  56.     require(service.addRange("M0", 1).succeeded

  57.                 && service.addRange("D0", 1).succeeded,

  58.             "monitor service must accept one M and one D address");

  59. 

  60.     virtual_repository.writeBit({RegisterArea::M, 0}, true);

  61.     virtual_repository.writeWord({RegisterArea::D, 0}, -123);

  62.     std::vector<MonitorValue> values = service.values(false);

  63.     require(values.size() == 2U && values[0].bitValue

  64.                 && std::get<std::int16_t>(values[1].numericValue) == -123,

  65.             "monitor values must reflect the active virtual repository");

  66. 

  67.     plc_repository.writeBit({RegisterArea::M, 0}, false);

  68.     plc_repository.writeWord({RegisterArea::D, 0}, 456);

  69.     active_repository.use(plc_repository);

  70.     values = service.values(false);

  71.     require(!values[0].bitValue

  72.                 && std::get<std::int16_t>(values[1].numericValue) == 456,

  73.             "monitor values must follow the active repository switch");

  74.     values = service.values(true);

  75.     require(values[0].state == MonitorValueState::CommunicationFault

  76.                 && values[1].state == MonitorValueState::CommunicationFault,

  77.             "valid cached values must be marked stale during a communication fault");

  78. }

  79. 

  80. void testEditingPlcMonitorAccess()

  81. {

  82.     VirtualRegisterRepository virtual_repository;

  83.     VirtualRegisterRepository plc_repository;

  84.     ActiveRegisterRepository active_repository(virtual_repository);

  85.     VirtualRegisterRepository initial_repository;

  86.     RegisterMonitorService service(active_repository);

  87.     service.setOfflineInitialRepository(initial_repository);

  88.     service.setOfflineInitialCaptureEnabled(true);

  89.     service.setEditingPlcRepository(plc_repository);

  90.     service.setEditingModeActive(true);

  91.     require(service.addRange("M0", 1).succeeded

  92.                 && service.addRange("D0", 1).succeeded,

  93.             "editing PLC monitor fixture must accept M and D points");

  94. 

  95.     virtual_repository.writeBit({RegisterArea::M, 0}, false);

  96.     virtual_repository.writeWord({RegisterArea::D, 0}, 11);

  97.     plc_repository.writeBit({RegisterArea::M, 0}, true);

  98.     plc_repository.writeWord({RegisterArea::D, 0}, 22);

  99. 

  100.     service.setEditingPlcState(true, false);

  101.     std::vector<MonitorValue> values = service.values(false);

  102.     require(values.size() == 2U && !values[0].bitValue

  103.                 && std::get<std::int16_t>(values[1].numericValue) == 11,

  104.             "connecting a PLC must not automatically replace the offline editing source");

  105.     const EditingMonitorSourceResult first_read_rejected =

  106.         service.selectEditingSource(EditingMonitorSource::Plc);

  107.     require(!first_read_rejected.succeeded

  108.                 && service.editingSource() == EditingMonitorSource::Offline,

  109.             "editing monitor must reject PLC selection before the first read");

  110. 

  111.     service.setEditingPlcState(true, true);

  112.     require(service.editingSource() == EditingMonitorSource::Offline

  113.                 && service.selectEditingSource(EditingMonitorSource::Plc).succeeded,

  114.             "a completed first read must allow an explicit PLC source selection");

  115.     values = service.values(false);

  116.     require(values[0].state == MonitorValueState::Valid && values[0].bitValue

  117.                 && values[1].state == MonitorValueState::Valid

  118.                 && std::get<std::int16_t>(values[1].numericValue) == 22,

  119.             "editing PLC monitor must display PLC cache values after first read");

  120.     require(service.writeBit({RegisterArea::M, 0}, false).succeeded

  121.                 && service.writeNumeric(

  122.                     {RegisterArea::D, 0}, RegisterDataType::Int16, 33).succeeded

  123.                 && !plc_repository.readBit({RegisterArea::M, 0}).value

  124.                 && plc_repository.readWord({RegisterArea::D, 0}).value == 33

  125.                 && !initial_repository.readBit({RegisterArea::M, 0}).value

  126.                 && initial_repository.readWord({RegisterArea::D, 0}).value == 0,

  127.             "editing PLC monitor writes must target PLC and skip offline capture");

  128. 

  129.     service.setEditingModeActive(false);

  130.     values = service.values(false);

  131.     require(!values[0].bitValue

  132.                 && std::get<std::int16_t>(values[1].numericValue) == 11,

  133.             "runtime access must keep following the active repository");

  134.     service.setEditingModeActive(true);

  135. 

  136.     service.setEditingPlcState(false, false);

  137.     values = service.values(false);

  138.     require(service.editingSource() == EditingMonitorSource::Plc

  139.                 && values[0].state == MonitorValueState::Unavailable

  140.                 && values[1].state == MonitorValueState::Unavailable

  141.                 && !service.writeBit({RegisterArea::M, 0}, true).succeeded,

  142.             "a PLC disconnect must preserve the selected source and prohibit access");

  143.     service.setEditingPlcState(true, true);

  144.     values = service.values(false);

  145.     require(service.editingSource() == EditingMonitorSource::Plc

  146.                 && !values[0].bitValue

  147.                 && std::get<std::int16_t>(values[1].numericValue) == 33,

  148.             "reconnection and a new first read must resume the selected PLC source");

  149.     service.setEditingPlcState(false, false);

  150.     require(service.selectEditingSource(EditingMonitorSource::Offline).succeeded,

  151.             "offline source must remain selectable while PLC is disconnected");

  152.     values = service.values(false);

  153.     require(!values[0].bitValue

  154.                 && std::get<std::int16_t>(values[1].numericValue) == 11,

  155.             "explicit offline selection must restore virtual editing values");

  156. }

  157. 

  158. void testRegisterWrites()

  159. {

  160.     VirtualRegisterRepository repository;

  161.     RegisterMonitorService service(repository);

  162.     const RegisterAddress m0{RegisterArea::M, 0};

  163.     const RegisterAddress d0{RegisterArea::D, 0};

  164. 

  165.     const RegisterMonitorWriteResult bit_write = service.writeBit(m0, true);

  166.     require(bit_write.succeeded && repository.readBit(m0).value,

  167.             "monitor service must write M values through the active repository");

  168. 

  169.     const RegisterMonitorWriteResult word_write = service.writeNumeric(

  170.         d0, RegisterDataType::Int16, -123);

  171.     require(word_write.succeeded && repository.readWord(d0).value == -123,

  172.             "monitor service must write signed D values through the active repository");

  173. 

  174.     const RegisterMonitorWriteResult wrong_bit = service.writeBit(d0, true);

  175.     require(!wrong_bit.succeeded && wrong_bit.error == RegisterError::AreaMismatch,

  176.             "monitor bit writes must reject D addresses");

  177.     const RegisterMonitorWriteResult wrong_word = service.writeNumeric(

  178.         m0, RegisterDataType::Int16, 123);

  179.     require(!wrong_word.succeeded && wrong_word.error == RegisterError::AreaMismatch,

  180.             "monitor word writes must reject M addresses");

  181. 

  182.     require(service.writeNumeric(

  183.                 d0, RegisterDataType::Int16, static_cast<std::int16_t>(-32768)).succeeded

  184.                 && repository.readWord(d0).value == -32768

  185.                 && service.writeNumeric(

  186.                     d0, RegisterDataType::Int16, static_cast<std::int16_t>(32767)).succeeded

  187.                 && repository.readWord(d0).value == 32767,

  188.             "monitor word writes must preserve signed 16-bit boundary values");

  189. }

  190. 

  191. void testOfflineInitialValueCapture()

  192. {

  193.     VirtualRegisterRepository virtual_repository;

  194.     VirtualRegisterRepository initial_repository;

  195.     ActiveRegisterRepository active_repository(virtual_repository);

  196.     RegisterMonitorService service(active_repository);

  197.     service.setOfflineInitialRepository(initial_repository);

  198.     service.setOfflineInitialCaptureEnabled(true);

  199. 

  200.     require(service.writeBit({RegisterArea::M, 3}, true).succeeded

  201.                 && service.writeNumeric(

  202.                     {RegisterArea::D, 10}, RegisterDataType::Int16, -456).succeeded

  203.                 && service.writeNumeric(

  204.                     {RegisterArea::D, 20}, RegisterDataType::Float32, 1.5f).succeeded

  205.                 && service.writeNumeric(

  206.                     {RegisterArea::D, 30}, RegisterDataType::Int32, 305419896)

  207.                     .succeeded

  208.                 && service.writeNumeric(

  209.                     {RegisterArea::D, 40}, RegisterDataType::Float64, 1.0)

  210.                     .succeeded,

  211.             "editing monitor writes must succeed against the virtual repository");

  212.     const WordsReadResult captured_int32 = initial_repository.readWords(

  213.         {RegisterArea::D, 30}, 2);

  214.     const WordsReadResult captured_double = initial_repository.readWords(

  215.         {RegisterArea::D, 40}, 4);

  216.     require(initial_repository.readBit({RegisterArea::M, 3}).value

  217.                 && initial_repository.readWord({RegisterArea::D, 10}).value == -456

  218.                 && std::fabs(Float32Codec::decode(

  219.                     initial_repository.readWords({RegisterArea::D, 20}, 2).values[0],

  220.                     initial_repository.readWords({RegisterArea::D, 20}, 2).values[1])

  221.                         .value_or(0.0f) - 1.5f) < 0.000001f,

  222.             "editing monitor writes must be captured as offline initial values");

  223.     require(captured_int32.succeeded

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

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

  226.                 && captured_double.succeeded

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

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

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

  230.                 && static_cast<std::uint16_t>(captured_double.values[3]) == 0x3ff0U,

  231.             "offline initial capture must keep all Int32 and Double words");

  232. 

  233.     service.setOfflineInitialCaptureEnabled(false);

  234.     require(service.writeBit({RegisterArea::M, 3}, false).succeeded

  235.                 && initial_repository.readBit({RegisterArea::M, 3}).value,

  236.             "runtime writes must not overwrite the captured initial values");

  237. }

  238. 

  239. void testMultiWordMonitoring()

  240. {

  241.     VirtualRegisterRepository repository;

  242.     RegisterMonitorService service(repository);

  243.     const RegisterMonitorResult added = service.addRange(

  244.         "D1", 3, RegisterDataType::Float32);

  245.     require(added.succeeded && added.affectedCount == 3

  246.                 && service.points().size() == 3U

  247.                 && service.points()[0].address == RegisterAddress{RegisterArea::D, 1}

  248.                 && service.points()[1].address == RegisterAddress{RegisterArea::D, 3}

  249.                 && service.points()[2].address == RegisterAddress{RegisterArea::D, 5},

  250.             "Float32 monitor batches must advance by two D words");

  251.     require(service.multiWordRanges().size() == 3U

  252.                 && service.multiWordRanges().front().wordCount == 2

  253.                 && service.pollAddresses().size() == 6U,

  254.             "Float32 monitor points must expose both words for polling");

  255. 

  256.     const RegisterMonitorResult duplicate = service.addRange(

  257.         "D1", 1, RegisterDataType::Float32);

  258.     require(!duplicate.succeeded && duplicate.error == RegisterMonitorError::NoChange,

  259.             "identical Float32 monitor points must be rejected");

  260.     const RegisterMonitorResult overlap = service.addRange(

  261.         "D2", 1, RegisterDataType::Int16);

  262.     require(overlap.succeeded && !overlap.message.empty(),

  263.             "partially overlapping monitor points must be added with a warning");

  264.     require(service.remove(std::vector<MonitorPoint>{

  265.                 MonitorPoint{{RegisterArea::D, 2}, RegisterDataType::Int16}}).succeeded

  266.                 && service.points().size() == 3U,

  267.             "overlapping monitor removal must identify the point type");

  268. 

  269.     require(service.writeNumeric(

  270.                 {RegisterArea::D, 1}, RegisterDataType::Float32, -2.5f).succeeded,

  271.             "Float32 monitor writes must use the pair write path");

  272.     std::vector<MonitorValue> values = service.values(false);

  273.     require(values.front().state == MonitorValueState::Valid

  274.                 && std::fabs(

  275.                     std::get<float>(values.front().numericValue) - (-2.5f))

  276.                     < 0.000001f,

  277.             "Float32 monitor values must decode the pair correctly");

  278.     require(!service.writeNumeric(

  279.                 {RegisterArea::D, 4000}, RegisterDataType::Float32, 1.0f).succeeded,

  280.             "Float32 monitor writes at D4000 must be rejected");

  281. 

  282.     const RegisterMonitorResult int32_added = service.addRange(

  283.         "D10", 2, RegisterDataType::Int32);

  284.     const RegisterMonitorResult double_added = service.addRange(

  285.         "D20", 2, RegisterDataType::Float64);

  286.     require(int32_added.succeeded && double_added.succeeded

  287.                 && service.points()[3].address == RegisterAddress{RegisterArea::D, 10}

  288.                 && service.points()[4].address == RegisterAddress{RegisterArea::D, 12}

  289.                 && service.points()[5].address == RegisterAddress{RegisterArea::D, 20}

  290.                 && service.points()[6].address == RegisterAddress{RegisterArea::D, 24}

  291.                 && service.pollAddresses().size() == 18U

  292.                 && service.multiWordRanges().size() == 7U

  293.                 && service.multiWordRanges()[5].wordCount == 4,

  294.             "Int32 and Double monitor batches must advance by their word counts");

  295.     require(service.writeNumeric(

  296.                 {RegisterArea::D, 10}, RegisterDataType::Int32, 305419896)

  297.                 .succeeded

  298.                 && service.writeNumeric(

  299.                     {RegisterArea::D, 20}, RegisterDataType::Float64, 1.25)

  300.                     .succeeded,

  301.             "Int32 and Double monitor writes must use continuous word blocks");

  302.     values = service.values(false);

  303.     require(std::get<std::int32_t>(values[3].numericValue) == 0x12345678

  304.                 && std::get<double>(values[5].numericValue) == 1.25,

  305.             "Int32 and Double monitor values must decode to their exact types");

  306. }

  307. 

  308. void testMultiWordMonitoringBoundaries()

  309. {

  310.     VirtualRegisterRepository repository;

  311.     RegisterMonitorService boundary_service(repository);

  312.     require(boundary_service.addRange(

  313.                 "D3999", 1, RegisterDataType::Int32).succeeded

  314.                 && !boundary_service.addRange(

  315.                     "D4000", 1, RegisterDataType::Int32).succeeded

  316.                 && boundary_service.addRange(

  317.                     "D3996", 1, RegisterDataType::Float64).succeeded

  318.                 && !boundary_service.addRange(

  319.                     "D3997", 1, RegisterDataType::Float64).succeeded

  320.                 && !boundary_service.addRange(

  321.                     "D21", 1, RegisterDataType::Float64).succeeded

  322.                 && !boundary_service.addRange(

  323.                     "M10", 1, RegisterDataType::Int32).succeeded,

  324.             "multi-word monitor points must enforce D limits and Double alignment");

  325. 

  326.     RegisterMonitorService validated_service(repository);

  327.     validated_service.setPollConfigurationValidator(

  328.         [](const std::vector<RegisterAddress> &,

  329.            const std::vector<RegisterWordRange> &ranges)

  330.         {

  331.             return ranges.empty() ? std::string{} : std::string{"轮询范围被拒绝"};

  332.         });

  333.     const RegisterMonitorResult rejected = validated_service.addRange(

  334.         "D100", 1, RegisterDataType::Float64);

  335.     require(!rejected.succeeded

  336.                 && rejected.error == RegisterMonitorError::PollConfigurationRejected

  337.                 && validated_service.points().empty(),

  338.             "a rejected candidate poll configuration must not change monitor points");

  339. }

  340. 

  341. } // namespace

  342. 

  343. int main()

  344. {

  345.     return TestSupport::runTestSuite("register monitor service tests", {

  346.         {"testRangeManagement", testRangeManagement},

  347.         {"testSharedActiveRepositoryValues", testSharedActiveRepositoryValues},

  348.         {"testEditingPlcMonitorAccess", testEditingPlcMonitorAccess},

  349.         {"testRegisterWrites", testRegisterWrites},

  350.         {"testOfflineInitialValueCapture", testOfflineInitialValueCapture},

  351.         {"testMultiWordMonitoring", testMultiWordMonitoring},

  352.         {"testMultiWordMonitoringBoundaries", testMultiWordMonitoringBoundaries},

  353.     });

  354. }