add unittest for reading coils, holding registers, input registers and discrete inputs partially, contributes to brainelectronics#35

Author: brainelectronics

tests/test_tcp_example.py

@@ -288,6 +288,45 @@ def test_read_coils_multiple(self) -> None:
         self.assertTrue(all(isinstance(x, bool) for x in coil_status))
         self.assertEqual(coil_status, expectation_list)
 
+    # Reading coil data bits is reversed
+    # see https://github.com/brainelectronics/micropython-modbus/issues/38
+    #
+    # Read/Write register at some location of definition
+    # see https://github.com/brainelectronics/micropython-modbus/issues/35
+    def test_read_coils_partially(self) -> None:
+        """Test reading coils partially of client"""
+        coil_address = \
+            self._register_definitions['COILS']['MANY_COILS']['register']
+        coil_qty = \
+            self._register_definitions['COILS']['MANY_COILS']['len']
+        expectation_list_full = list(
+            map(bool,
+                self._register_definitions['COILS']['MANY_COILS']['val'])
+        )
+
+        coil_qty_less_8 = randint(2, 7)
+        coil_qty_more_8 = randint(8, coil_qty - 1)
+        possibilities = [coil_qty_less_8, coil_qty_more_8]
+
+        for partial_coil_qty in possibilities:
+            with self.subTest(partial_coil_qty=partial_coil_qty):
+                expectation_list_partial = \
+                    expectation_list_full[:partial_coil_qty]
+
+                coil_status = self._host.read_coils(
+                    slave_addr=self._client_addr,
+                    starting_addr=coil_address,
+                    coil_qty=partial_coil_qty)
+
+                self.test_logger.debug(
+                    'Status of COIL {} length {}/{}: {}, expectation: {}'.
+                    format(coil_address, partial_coil_qty, coil_qty,
+                           coil_status, expectation_list_partial))
+                self.assertIsInstance(coil_status, list)
+                self.assertEqual(len(coil_status), partial_coil_qty)
+                self.assertTrue(all(isinstance(x, bool) for x in coil_status))
+                self.assertEqual(coil_status, expectation_list_partial)
+
     def test_read_discrete_inputs_single(self) -> None:
         """Test reading discrete inputs of client"""
         ist_address = \
@@ -353,6 +392,39 @@ def test_read_discrete_inputs_multiple(self) -> None:
         self.assertTrue(all(isinstance(x, bool) for x in input_status))
         self.assertEqual(input_status, expectation_list)
 
+    # Read/Write register at some location of definition
+    # see https://github.com/brainelectronics/micropython-modbus/issues/35
+    def test_read_discrete_inputs_partially(self) -> None:
+        """Test reading discrete inputs partially of client"""
+        ist_address = \
+            self._register_definitions['ISTS']['ANOTHER_EXAMPLE_ISTS']['register']     # noqa: E501
+        input_qty = \
+            self._register_definitions['ISTS']['ANOTHER_EXAMPLE_ISTS']['len']
+        expectation_list_full = \
+            self._register_definitions['ISTS']['ANOTHER_EXAMPLE_ISTS']['val']
+
+        input_qty_less = input_qty - 1
+        possibilities = [input_qty_less]
+
+        for partial_input_qty in possibilities:
+            with self.subTest(partial_input_qty=partial_input_qty):
+                expectation_list_partial = \
+                    expectation_list_full[:partial_input_qty]
+
+                input_status = self._host.read_discrete_inputs(
+                    slave_addr=self._client_addr,
+                    starting_addr=ist_address,
+                    input_qty=partial_input_qty)
+
+                self.test_logger.debug(
+                    'Status of IST {} length {}/{}: {}, expectation: {}'.
+                    format(ist_address, partial_input_qty, input_qty,
+                           input_status, expectation_list_partial))
+                self.assertIsInstance(input_status, list)
+                self.assertEqual(len(input_status), partial_input_qty)
+                self.assertTrue(all(isinstance(x, bool) for x in input_status))
+                self.assertEqual(input_status, expectation_list_partial)
+
     def test_read_holding_registers_single(self) -> None:
         """Test reading holding registers of client"""
         # read holding register with negative value
@@ -427,6 +499,40 @@ def test_read_holding_registers_multiple(self) -> None:
         self.assertTrue(all(isinstance(x, int) for x in register_value))
         self.assertEqual(register_value, expectation)
 
+    # Read/Write register at some location of definition
+    # see https://github.com/brainelectronics/micropython-modbus/issues/35
+    def test_read_holding_registers_partially(self) -> None:
+        """Test reading holding registers partially of client"""
+        hreg_address = \
+            self._register_definitions['HREGS']['ANOTHER_EXAMPLE_HREG']['register']     # noqa: E501
+        register_qty = \
+            self._register_definitions['HREGS']['ANOTHER_EXAMPLE_HREG']['len']
+        expectation_tuple_full = tuple(
+            self._register_definitions['HREGS']['ANOTHER_EXAMPLE_HREG']['val']
+        )
+        register_qty_less = register_qty - 1
+        possibilities = [register_qty_less]
+
+        for partial_register_qty in possibilities:
+            with self.subTest(partial_register_qty=partial_register_qty):
+                expectation_tuple_partial = \
+                    expectation_tuple_full[:partial_register_qty]
+
+                register_value = self._host.read_holding_registers(
+                    slave_addr=self._client_addr,
+                    starting_addr=hreg_address,
+                    register_qty=partial_register_qty)
+
+                self.test_logger.debug(
+                    'Status of HREG {} length {}/{}: {}, expectation: {}'.
+                    format(hreg_address, partial_register_qty, register_qty,
+                           register_value, expectation_tuple_partial))
+                self.assertIsInstance(register_value, tuple)
+                self.assertEqual(len(register_value), partial_register_qty)
+                self.assertTrue(all(isinstance(x, int)
+                                for x in register_value))
+                self.assertEqual(register_value, expectation_tuple_partial)
+
     def test_read_input_registers_single(self) -> None:
         """Test reading input registers of client"""
         ireg_address = \
@@ -475,6 +581,41 @@ def test_read_input_registers_multiple(self) -> None:
         self.assertTrue(all(isinstance(x, int) for x in register_value))
         self.assertEqual(register_value, expectation)
 
+    # Read/Write register at some location of definition
+    # see https://github.com/brainelectronics/micropython-modbus/issues/35
+    def test_read_input_registers_partially(self) -> None:
+        """Test reading input registers partially of client"""
+        ireg_address = \
+            self._register_definitions['IREGS']['ANOTHER_EXAMPLE_IREG']['register']     # noqa: E501
+        register_qty = \
+            self._register_definitions['IREGS']['ANOTHER_EXAMPLE_IREG']['len']
+        expectation_tuple_full = tuple(
+            self._register_definitions['IREGS']['ANOTHER_EXAMPLE_IREG']['val']
+        )
+        register_qty_less = register_qty - 1
+        possibilities = [register_qty_less]
+
+        for partial_register_qty in possibilities:
+            with self.subTest(partial_register_qty=partial_register_qty):
+                expectation_tuple_partial = \
+                    expectation_tuple_full[:partial_register_qty]
+
+                register_value = self._host.read_input_registers(
+                    slave_addr=self._client_addr,
+                    starting_addr=ireg_address,
+                    register_qty=partial_register_qty,
+                    signed=False)
+
+                self.test_logger.debug(
+                    'Status of IREG {} length {}/{}: {}, expectation: {}'.
+                    format(ireg_address, partial_register_qty, register_qty,
+                           register_value, expectation_tuple_partial))
+                self.assertIsInstance(register_value, tuple)
+                self.assertEqual(len(register_value), partial_register_qty)
+                self.assertTrue(all(isinstance(x, int)
+                                for x in register_value))
+                self.assertEqual(register_value, expectation_tuple_partial)
+
     def test_reset_client_data(self) -> None:
         """Test resettig client data to default"""
         coil_address = \