pyModbusTCP 0.2.2__tar.gz → 0.3.0__tar.gz

{pyModbusTCP-0.2.2 → pyModbusTCP-0.3.0}/CHANGES

@@ -1,5 +1,10 @@
 Revision history for pyModbusTCP
 
+0.3.0 2024-09-04
+
+    - pyModbusTCP.client: now use the standard logging method as in the server part.
+    - ModbusClient: debug flag is removed (see examples/client_debug.py).
+
 0.2.2 2024-07-31
 
     - fix ModbusServer: wrong check of discrete inputs length in DataBank (thanks to OTnetproj).

{pyModbusTCP-0.2.2/pyModbusTCP.egg-info → pyModbusTCP-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyModbusTCP
-Version: 0.2.2
+Version: 0.3.0
 Summary: A simple Modbus/TCP library for Python
 Home-page: https://github.com/sourceperl/pyModbusTCP
 Author: Loic Lefebvre

{pyModbusTCP-0.2.2 → pyModbusTCP-0.3.0}/pyModbusTCP/__init__.py

@@ -6,12 +6,14 @@
 #                 1,2,4,5,6 (Class 1)
 #                 15,23,43
 
-from .constants import VERSION
+import logging
 
+from .constants import VERSION
 
-__all__ = ['constants', 'client', 'server', 'utils']
 __title__ = 'pyModbusTCP'
 __description__ = 'A simple Modbus/TCP library for Python.'
 __url__ = 'https://github.com/sourceperl/pyModbusTCP'
 __version__ = VERSION
 __license__ = 'MIT'
+
+logger = logging.getLogger(__name__)

{pyModbusTCP-0.2.2 → pyModbusTCP-0.3.0}/pyModbusTCP/client.py

@@ -1,23 +1,34 @@
 """ pyModbusTCP Client """
 
-from dataclasses import dataclass, field
-from .constants import READ_COILS, READ_DISCRETE_INPUTS, READ_HOLDING_REGISTERS, READ_INPUT_REGISTERS, \
-    WRITE_MULTIPLE_COILS, WRITE_MULTIPLE_REGISTERS, WRITE_SINGLE_COIL, WRITE_SINGLE_REGISTER, \
-    WRITE_READ_MULTIPLE_REGISTERS, ENCAPSULATED_INTERFACE_TRANSPORT, MEI_TYPE_READ_DEVICE_ID, \
-    MB_ERR_TXT, MB_NO_ERR, MB_SEND_ERR, MB_RECV_ERR, MB_TIMEOUT_ERR, MB_EXCEPT_ERR, MB_CONNECT_ERR, \
-    EXP_TXT, EXP_DETAILS, EXP_NONE, MB_SOCK_CLOSE_ERR, VERSION
-from .utils import byte_length, set_bit, valid_host
+import logging
 import random
 import socket
-from socket import AF_UNSPEC, SOCK_STREAM
 import struct
+from binascii import hexlify
+from dataclasses import dataclass, field
+from socket import AF_UNSPEC, SOCK_STREAM
 from typing import Dict
 
+from .constants import (ENCAPSULATED_INTERFACE_TRANSPORT, EXP_DETAILS,
+                        EXP_NONE, EXP_TXT, MB_CONNECT_ERR, MB_ERR_TXT,
+                        MB_EXCEPT_ERR, MB_NO_ERR, MB_RECV_ERR, MB_SEND_ERR,
+                        MB_SOCK_CLOSE_ERR, MB_TIMEOUT_ERR,
+                        MEI_TYPE_READ_DEVICE_ID, READ_COILS,
+                        READ_DISCRETE_INPUTS, READ_HOLDING_REGISTERS,
+                        READ_INPUT_REGISTERS, VERSION, WRITE_MULTIPLE_COILS,
+                        WRITE_MULTIPLE_REGISTERS,
+                        WRITE_READ_MULTIPLE_REGISTERS, WRITE_SINGLE_COIL,
+                        WRITE_SINGLE_REGISTER)
+from .utils import byte_length, set_bit, valid_host
+
+# add a logger for pyModbusTCP.client
+logger = logging.getLogger(__name__)
+
 
 @dataclass
 class DeviceIdentificationResponse:
     """Modbus TCP client function read_device_identification() response struct.
-    
+
     :param conformity_level: this represents supported access and object type
     :type conformity_level: int
     :param more_follows: for stream request can be set to 0xff if other objects are available (0x00 in other cases)
@@ -76,8 +87,7 @@ class ModbusClient:
         def __init__(self, code):
             self.code = code
 
-    def __init__(self, host='localhost', port=502, unit_id=1, timeout=30.0,
-                 debug=False, auto_open=True, auto_close=False):
+    def __init__(self, host='localhost', port=502, unit_id=1, timeout=30.0, auto_open=True, auto_close=False):
         """Constructor.
 
         :param host: hostname or IPv4/IPv6 address server address
@@ -88,8 +98,6 @@ class ModbusClient:
         :type unit_id: int
         :param timeout: socket timeout in seconds
         :type timeout: float
-        :param debug: debug state
-        :type debug: bool
         :param auto_open: auto TCP connect
         :type auto_open: bool
         :param auto_close: auto TCP close)
@@ -103,7 +111,6 @@ class ModbusClient:
         self._port = None
         self._unit_id = None
         self._timeout = None
-        self._debug = None
         self._auto_open = None
         self._auto_close = None
         self._sock = socket.socket()
@@ -117,13 +124,12 @@ class ModbusClient:
         self.port = port
         self.unit_id = unit_id
         self.timeout = timeout
-        self.debug = debug
         self.auto_open = auto_open
         self.auto_close = auto_close
 
     def __repr__(self):
-        r_str = 'ModbusClient(host=\'%s\', port=%d, unit_id=%d, timeout=%.2f, debug=%s, auto_open=%s, auto_close=%s)'
-        r_str %= (self.host, self.port, self.unit_id, self.timeout, self.debug, self.auto_open, self.auto_close)
+        r_str = 'ModbusClient(host=\'%s\', port=%d, unit_id=%d, timeout=%.2f, auto_open=%s, auto_close=%s)'
+        r_str %= (self.host, self.port, self.unit_id, self.timeout, self.auto_open, self.auto_close)
         return r_str
 
     def __del__(self):
@@ -248,16 +254,6 @@ class ModbusClient:
         # can't be set
         raise ValueError('timeout can\'t be set (valid between 0 and 3600)')
 
-    @property
-    def debug(self):
-        """Get or set the debug flag (True = turn on)."""
-        return self._debug
-
-    @debug.setter
-    def debug(self, value):
-        # enforce type
-        self._debug = bool(value)
-
     @property
     def auto_open(self):
         """Get or set automatic TCP connect mode (True = turn on)."""
@@ -521,7 +517,8 @@ class ModbusClient:
             raise ValueError('object_id out of range (valid from 0 to 255)')
         # make request
         try:
-            tx_pdu = struct.pack('BBBB', ENCAPSULATED_INTERFACE_TRANSPORT, MEI_TYPE_READ_DEVICE_ID, read_code, object_id)
+            tx_pdu = struct.pack('BBBB', ENCAPSULATED_INTERFACE_TRANSPORT,
+                                 MEI_TYPE_READ_DEVICE_ID, read_code, object_id)
             rx_pdu = self._req_pdu(tx_pdu=tx_pdu, rx_min_len=7)
             # init response object for populate it
             response = DeviceIdentificationResponse()
@@ -800,7 +797,7 @@ class ModbusClient:
         # send frame with error check
         self._send(tx_frame)
         # debug
-        self._debug_dump('Tx', tx_frame)
+        self._on_tx_rx(frame=tx_frame, is_tx=True)
 
     def _recv(self, size):
         """Receive data over current socket.
@@ -856,7 +853,7 @@ class ModbusClient:
         # checking error status of fields
         if f_transaction_err or f_protocol_err or f_length_err or f_unit_id_err:
             self.close()
-            self._debug_dump('Rx', rx_mbap)
+            self._on_tx_rx(frame=rx_mbap, is_tx=False)
             raise ModbusClient._NetworkError(MB_RECV_ERR, 'MBAP checking error')
         # recv PDU
         rx_pdu = self._recv_all(f_length - 1)
@@ -864,7 +861,7 @@ class ModbusClient:
         if self.auto_close:
             self.close()
         # dump frame
-        self._debug_dump('Rx', rx_mbap + rx_pdu)
+        self._on_tx_rx(frame=rx_mbap + rx_pdu, is_tx=False)
         # body decode
         # check PDU length for global minimal frame (an except frame: func code + exp code)
         if len(rx_pdu) < 2:
@@ -929,45 +926,21 @@ class ModbusClient:
         if isinstance(_except, ModbusClient._ModbusExcept):
             self._last_error = MB_EXCEPT_ERR
             self._last_except = _except.code
-            self._debug_msg('modbus exception (code %d "%s")' % (self.last_except, self.last_except_as_txt))
-
-    def _debug_msg(self, msg):
-        """Print debug message if debug mode is on.
-
-        :param msg: debug message
-        :type msg: str
-        """
-        if self.debug:
-            print(msg)
-
-    def _debug_dump(self, label, frame):
-        """Print debug dump if debug mode is on.
-
-        :param label: head label
-        :type label: str
-        :param frame: modbus frame
-        :type frame: bytes
-        """
-        if self.debug:
-            self._pretty_dump(label, frame)
-
-    @staticmethod
-    def _pretty_dump(label, frame):
-        """Dump a modbus frame.
-
-        modbus/TCP format: [MBAP] PDU
-
-        :param label: head label
-        :type label: str
-        :param frame: modbus frame
-        :type frame: bytes
-        """
-        # split data string items to a list of hex value
-        dump = ['%02X' % c for c in frame]
-        # format message
-        dump_mbap = ' '.join(dump[0:7])
-        dump_pdu = ' '.join(dump[7:])
-        msg = '[%s] %s' % (dump_mbap, dump_pdu)
-        # print result
-        print(label)
-        print(msg)
+            self._debug_msg(f'modbus exception (code {self.last_except} "{self.last_error_as_txt}")')
+
+    def _debug_msg(self, msg: str):
+        logger.debug(f'({self.host}:{self.port}:{self.unit_id}) {msg}')
+
+    def _on_tx_rx(self, frame: bytes, is_tx: bool):
+        # format a log message
+        if logger.isEnabledFor(logging.DEBUG):
+            type_s = 'Tx' if is_tx else 'Rx'
+            mbap_s = hexlify(frame[0:7], sep=' ').upper().decode()
+            pdu_s = hexlify(frame[7:], sep=' ').upper().decode()
+            self._debug_msg(f'{type_s} [{mbap_s}] {pdu_s}')
+        # notify user
+        self.on_tx_rx(frame=frame, is_tx=is_tx)
+
+    def on_tx_rx(self, frame: bytes, is_tx: bool):
+        """Call for each Tx/Rx (for user purposes)."""
+        pass

{pyModbusTCP-0.2.2 → pyModbusTCP-0.3.0}/pyModbusTCP/constants.py

@@ -1,7 +1,7 @@
 """ pyModbusTCP package constants definition """
 
 # Package version
-VERSION = '0.2.2'
+VERSION = '0.3.0'
 # Modbus/TCP
 MODBUS_PORT = 502
 # Modbus function code

{pyModbusTCP-0.2.2 → pyModbusTCP-0.3.0}/pyModbusTCP/server.py

@@ -1,19 +1,24 @@
 """ pyModbusTCP Server """
 
-from .constants import READ_COILS, READ_DISCRETE_INPUTS, READ_HOLDING_REGISTERS, READ_INPUT_REGISTERS, \
-    WRITE_MULTIPLE_COILS, WRITE_MULTIPLE_REGISTERS, WRITE_SINGLE_COIL, WRITE_SINGLE_REGISTER, \
-    EXP_NONE, EXP_ILLEGAL_FUNCTION, EXP_DATA_ADDRESS, EXP_DATA_VALUE, WRITE_READ_MULTIPLE_REGISTERS, \
-    ENCAPSULATED_INTERFACE_TRANSPORT, MEI_TYPE_READ_DEVICE_ID, MAX_PDU_SIZE
-from .utils import test_bit, set_bit
 import logging
 import socket
-from socketserver import BaseRequestHandler, ThreadingTCPServer
 import struct
-from threading import Lock, Thread, Event
+from socketserver import BaseRequestHandler, ThreadingTCPServer
+from threading import Event, Lock, Thread
 from warnings import warn
 
+from .constants import (ENCAPSULATED_INTERFACE_TRANSPORT, EXP_DATA_ADDRESS,
+                        EXP_DATA_VALUE, EXP_ILLEGAL_FUNCTION, EXP_NONE,
+                        MAX_PDU_SIZE, MEI_TYPE_READ_DEVICE_ID, READ_COILS,
+                        READ_DISCRETE_INPUTS, READ_HOLDING_REGISTERS,
+                        READ_INPUT_REGISTERS, WRITE_MULTIPLE_COILS,
+                        WRITE_MULTIPLE_REGISTERS,
+                        WRITE_READ_MULTIPLE_REGISTERS, WRITE_SINGLE_COIL,
+                        WRITE_SINGLE_REGISTER)
+from .utils import set_bit, test_bit
+
 # add a logger for pyModbusTCP.server
-logger = logging.getLogger('pyModbusTCP.server')
+logger = logging.getLogger(__name__)
 
 
 class DataBank:
@@ -825,7 +830,7 @@ class ModbusServer:
             session_data = ModbusServer.SessionData()
             (session_data.client.address, session_data.client.port) = self.request.getpeername()
             # debug message
-            logger.debug('Accept new connection from %r', session_data.client)
+            logger.debug('accept new connection from %r', session_data.client)
             try:
                 # main processing loop
                 while True:

{pyModbusTCP-0.2.2 → pyModbusTCP-0.3.0/pyModbusTCP.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyModbusTCP
-Version: 0.2.2
+Version: 0.3.0
 Summary: A simple Modbus/TCP library for Python
 Home-page: https://github.com/sourceperl/pyModbusTCP
 Author: Loic Lefebvre

{pyModbusTCP-0.2.2 → pyModbusTCP-0.3.0}/pyModbusTCP.egg-info/SOURCES.txt

@@ -12,4 +12,8 @@ pyModbusTCP/utils.py
 pyModbusTCP.egg-info/PKG-INFO
 pyModbusTCP.egg-info/SOURCES.txt
 pyModbusTCP.egg-info/dependency_links.txt
-pyModbusTCP.egg-info/top_level.txt
+pyModbusTCP.egg-info/top_level.txt
+tests/test_client.py
+tests/test_client_server.py
+tests/test_server.py
+tests/test_utils.py

pyModbusTCP-0.3.0/tests/test_client.py

@@ -0,0 +1,58 @@
+""" Test of pyModbusTCP.ModbusClient """
+
+import unittest
+from pyModbusTCP.client import ModbusClient
+
+
+class TestModbusClient(unittest.TestCase):
+    """ ModbusClient tests class. """
+
+    def test_host(self):
+        """Test of host property."""
+        # default value
+        self.assertEqual(ModbusClient().host, 'localhost')
+        # should raise ValueError for bad value
+        self.assertRaises(ValueError, ModbusClient, host='wrong@host')
+        self.assertRaises(ValueError, ModbusClient, host='::notip:1')
+        # shouldn't raise ValueError for valid value
+        try:
+            [ModbusClient(host=h) for h in ['CamelCaseHost', 'plc-1.net', 'my.good.host',
+                                            '_test.example.com', '42.example.com',
+                                            '127.0.0.1', '::1']]
+        except ValueError:
+            self.fail('ModbusClient.host property raised ValueError unexpectedly')
+
+    def test_port(self):
+        """Test of port property."""
+        # default value
+        self.assertEqual(ModbusClient().port, 502)
+        # should raise an exception for bad value
+        self.assertRaises(TypeError, ModbusClient, port='amsterdam')
+        self.assertRaises(ValueError, ModbusClient, port=-1)
+        # shouldn't raise ValueError for valid value
+        try:
+            ModbusClient(port=5020)
+        except ValueError:
+            self.fail('ModbusClient.port property raised ValueError unexpectedly')
+
+    def test_unit_id(self):
+        """Test of unit_id property."""
+        # default value
+        self.assertEqual(ModbusClient().unit_id, 1)
+        # should raise an exception for bad unit_id
+        self.assertRaises(TypeError, ModbusClient, unit_id='@')
+        self.assertRaises(ValueError, ModbusClient, unit_id=420)
+        # shouldn't raise ValueError for valid value
+        try:
+            ModbusClient(port=5020)
+        except ValueError:
+            self.fail('ModbusClient.port property raised ValueError unexpectedly')
+
+    def test_misc(self):
+        """Check of misc default values."""
+        self.assertEqual(ModbusClient().auto_open, True)
+        self.assertEqual(ModbusClient().auto_close, False)
+
+
+if __name__ == '__main__':
+    unittest.main()

pyModbusTCP-0.3.0/tests/test_client_server.py

@@ -0,0 +1,214 @@
+""" Test of pyModbusTCP client-server interaction """
+
+import unittest
+from random import randint, getrandbits, choice
+from string import ascii_letters
+from pyModbusTCP.server import ModbusServer, DeviceIdentification
+from pyModbusTCP.client import ModbusClient, DeviceIdentificationResponse
+from pyModbusTCP.constants import SUPPORTED_FUNCTION_CODES, \
+    EXP_NONE, EXP_ILLEGAL_FUNCTION, EXP_DATA_ADDRESS, EXP_DATA_VALUE, MB_NO_ERR, MB_EXCEPT_ERR
+
+
+# some const
+MAX_READABLE_REGS = 125
+MAX_WRITABLE_REGS = 123
+MAX_WRITE_READ_REGS = 121
+MAX_READABLE_BITS = 2000
+MAX_WRITABLE_BITS = 1968
+
+
+class TestClientServer(unittest.TestCase):
+    """ Client-server interaction test class. """
+
+    def setUp(self):
+        """Init client-server for test_xxx methods."""
+        # modbus server
+        self.server = ModbusServer(port=5020, no_block=True)
+        self.server.start()
+        # modbus client
+        self.client = ModbusClient(port=5020)
+        self.client.open()
+
+    def tearDown(self):
+        """Cleanning after test."""
+        self.client.close()
+        self.server.stop()
+
+    def test_default_startup_values(self):
+        """Some read at random address to test startup values."""
+        for addr in [randint(0, 0xffff) for _ in range(100)]:
+            self.assertEqual(self.client.read_coils(addr), [False])
+            self.assertEqual(self.client.read_discrete_inputs(addr), [False])
+            self.assertEqual(self.client.read_holding_registers(addr), [0])
+            self.assertEqual(self.client.read_input_registers(addr), [0])
+
+    def test_read_write_requests(self):
+        """Test standard modbus functions."""
+        # coils
+        for addr in [0x0000, 0x1234, 0x2345, 0x10000 - MAX_WRITABLE_BITS]:
+            # coils space: single read/write
+            bit = bool(getrandbits(1))
+            self.assertEqual(self.client.write_single_coil(addr, bit), True)
+            self.assertEqual(self.client.read_coils(addr), [bit])
+            # coils space: multiple read/write at min size
+            bits_l = [bool(getrandbits(1))]
+            self.assertEqual(self.client.write_multiple_coils(addr, bits_l), True)
+            self.assertEqual(self.client.read_coils(addr, len(bits_l)), bits_l)
+            # coils space: multiple read/write at max size
+            bits_l = [bool(getrandbits(1)) for _ in range(MAX_WRITABLE_BITS)]
+            self.assertEqual(self.client.write_multiple_coils(addr, bits_l), True)
+            self.assertEqual(self.client.read_coils(addr, len(bits_l)), bits_l)
+            # coils space: oversized multi-write
+            bits_l.append(bool(getrandbits(1)))
+            self.assertRaises(ValueError, self.client.write_multiple_coils, addr, bits_l)
+        # coils space: read/write over limit
+        self.assertRaises(ValueError, self.client.read_coils, 0xfffe, 3)
+        self.assertRaises(ValueError, self.client.write_single_coil, 0x10000, False)
+        self.assertRaises(ValueError, self.client.write_multiple_coils, 0xfff0, [False] * 17)
+
+        # discrete inputs
+        for addr in [0x0000, 0x1234, 0x2345, 0x10000 - MAX_READABLE_BITS]:
+            # discrete inputs space: single read/write
+            bit = bool(getrandbits(1))
+            self.server.data_bank.set_discrete_inputs(addr, [bit])
+            self.assertEqual(self.client.read_discrete_inputs(addr), [bit])
+            # discrete inputs space: multiple read/write at min size
+            bits_l = [bool(getrandbits(1))]
+            self.server.data_bank.set_discrete_inputs(addr, bits_l)
+            self.assertEqual(self.client.read_discrete_inputs(addr, len(bits_l)), bits_l)
+            # discrete inputs space: multiple read/write at max size
+            bits_l = [bool(getrandbits(1)) for _ in range(MAX_READABLE_BITS)]
+            self.server.data_bank.set_discrete_inputs(addr, bits_l)
+            self.assertEqual(self.client.read_discrete_inputs(addr, len(bits_l)), bits_l)
+            # discrete inputs space: multiple read/write at max size
+            bits_l.append(bool(getrandbits(1)))
+            self.server.data_bank.set_discrete_inputs(addr, bits_l)
+            self.assertRaises(ValueError, self.client.read_discrete_inputs, addr, len(bits_l))
+        # discrete inputs space: read/write over limit
+        self.assertRaises(ValueError, self.client.read_discrete_inputs, 0xffff, 2)
+
+        # holding registers
+        for addr in [0x0000, 0x1234, 0x2345, 0x10000 - MAX_WRITABLE_REGS]:
+            # holding registers space: single read/write
+            word = randint(0, 0xffff)
+            self.assertEqual(self.client.write_single_register(addr, word), True)
+            self.assertEqual(self.client.read_holding_registers(addr), [word])
+            # holding registers space: multi-write at max size
+            words_l = [randint(0, 0xffff) for _ in range(MAX_WRITABLE_REGS)]
+            self.assertEqual(self.client.write_multiple_registers(addr, words_l), True)
+            self.assertEqual(self.client.read_holding_registers(addr, len(words_l)), words_l)
+            # holding registers space: multi-write at max size
+            words_l = [randint(0, 0xffff) for _ in range(MAX_WRITE_READ_REGS)]
+            self.assertEqual(self.client.write_read_multiple_registers(addr, words_l, addr, len(words_l)), words_l)
+            self.assertEqual(self.client.read_holding_registers(addr, len(words_l)), words_l)
+        # holding registers space: read/write over limit
+        self.assertRaises(ValueError, self.client.read_holding_registers, 0xfff0, 17)
+        self.assertRaises(ValueError, self.client.write_single_register, 0, 0x10000)
+        self.assertRaises(ValueError, self.client.write_single_register, 0x10000, 0)
+        self.assertRaises(ValueError, self.client.write_multiple_registers, 0x1000, [0x10000])
+        self.assertRaises(ValueError, self.client.write_multiple_registers, 0xfff0, [0] * 17)
+        self.assertRaises(ValueError, self.client.write_read_multiple_registers, 0x1000, [0x10000], 0x1000, 1)
+        self.assertRaises(ValueError, self.client.write_read_multiple_registers, 0xfff0, [0] * 17, 0xfff0, 1)
+        self.assertRaises(ValueError, self.client.write_read_multiple_registers, 0xfff0, [0] * 1, 0xfff0, 17)
+
+        # input registers
+        for addr in [0x0000, 0x1234, 0x2345, 0x10000 - MAX_READABLE_REGS]:
+            # input registers space: single read/write
+            word = randint(0, 0xffff)
+            self.server.data_bank.set_input_registers(addr, [word])
+            self.assertEqual(self.client.read_input_registers(addr), [word])
+            # input registers space: multiple read/write at max size
+            words_l = [randint(0, 0xffff) for _ in range(MAX_READABLE_REGS)]
+            self.server.data_bank.set_input_registers(addr, words_l)
+            self.assertEqual(self.client.read_input_registers(addr, len(words_l)), words_l)
+            # input registers space: multiple read/write over sized
+            words_l.append(randint(0, 0xffff))
+            self.server.data_bank.set_input_registers(addr, words_l)
+            self.assertRaises(ValueError, self.client.read_input_registers, addr, len(words_l))
+        # input registers space: read/write over limit
+        self.assertRaises(ValueError, self.client.read_input_registers, 0xfff0, 17)
+
+    def test_server_strength(self):
+        """Test server responses to abnormal events."""
+        # unsupported function codes must return except EXP_ILLEGAL_FUNCTION
+        for func_code in range(0x80):
+            if func_code not in SUPPORTED_FUNCTION_CODES:
+                # test with a min PDU length of 2 bytes (avoid short frame error)
+                self.assertEqual(self.client.custom_request(bytes([func_code, 0x00])), None)
+                self.assertEqual(self.client.last_error, MB_EXCEPT_ERR)
+                self.assertEqual(self.client.last_except, EXP_ILLEGAL_FUNCTION)
+        # check a regular request status: no error, no except
+        self.assertEqual(self.client.read_coils(0), [False])
+        self.assertEqual(self.client.last_error, MB_NO_ERR)
+        self.assertEqual(self.client.last_except, EXP_NONE)
+
+    def test_server_read_identification(self):
+        """Test server device indentification function."""
+        # forge a basic read identification on unconfigured server (return a data address except)
+        self.assertEqual(self.client.custom_request(b'\x2b\x0e\x01\x00'), None)
+        self.assertEqual(self.client.last_error, MB_EXCEPT_ERR)
+        self.assertEqual(self.client.last_except, EXP_DATA_ADDRESS)
+        # configure server
+        self.server.device_id = DeviceIdentification()
+        self.server.device_id.vendor_name = b'me'
+        self.server.device_id[0x80] = b'\xc0\xde'
+        # forge a basic read identification on a configured server (return a valid pdu)
+        self.assertNotEqual(self.client.custom_request(b'\x2b\x0e\x01\x00'), None)
+        # forge a read identifaction request with a bad read device id code (return except 3)
+        self.assertEqual(self.client.custom_request(b'\x2b\x0e\x05\x00'), None)
+        self.assertEqual(self.client.last_error, MB_EXCEPT_ERR)
+        self.assertEqual(self.client.last_except, EXP_DATA_VALUE)
+        # read VendorName str object(id #0) with individual access (read device id = 4)
+        ret_pdu = self.client.custom_request(b'\x2b\x0e\x04\x00')
+        self.assertEqual(ret_pdu, b'\x2b\x0e\x04\x83\x00\x00\x01\x00\x02me')
+        # read private int object(id #0x80) with individual access (read device id = 4)
+        ret_pdu = self.client.custom_request(b'\x2b\x0e\x04\x80')
+        self.assertEqual(ret_pdu, b'\x2b\x0e\x04\x83\x00\x00\x01\x80\x02\xc0\xde')
+        # restore default configuration
+        self.server.device_id = None
+
+    def test_client_read_identification(self):
+        """Test client device indentification function."""
+        # configure server
+        vendor_name = ''.join(choice(ascii_letters) for _ in range(16)).encode()
+        product_code = ''.join(choice(ascii_letters) for _ in range(32)).encode()
+        maj_min_rev = b'v2.0'
+        vendor_url = b'https://github.com/sourceperl/pyModbusTCP'
+        self.server.device_id = DeviceIdentification(vendor_name=vendor_name, product_code=product_code,
+                                                     major_minor_revision=maj_min_rev, vendor_url=vendor_url)
+        # read_device_identification: read basic device identification (stream access)
+        dev_id_resp = self.client.read_device_identification()
+        if not dev_id_resp:
+            self.fail('ModbusClient.read_device_identification() method failed unexpectedly')
+        else:
+            # return DeviceIdentificationResponse on success
+            self.assertEqual(isinstance(dev_id_resp, DeviceIdentificationResponse), True)
+            # check read data
+            self.assertEqual(len(dev_id_resp.objects_by_id), 3)
+            self.assertEqual(dev_id_resp.vendor_name, vendor_name)
+            self.assertEqual(dev_id_resp.objects_by_id.get(0), vendor_name)
+            self.assertEqual(dev_id_resp.product_code, product_code)
+            self.assertEqual(dev_id_resp.objects_by_id.get(1), product_code)
+            self.assertEqual(dev_id_resp.major_minor_revision, maj_min_rev)
+            self.assertEqual(dev_id_resp.objects_by_id.get(2), maj_min_rev)
+            self.assertEqual(dev_id_resp.vendor_url, None)
+            self.assertEqual(dev_id_resp.product_name, None)
+            self.assertEqual(dev_id_resp.model_name, None)
+            self.assertEqual(dev_id_resp.user_application_name, None)
+        # read_device_identification: read one specific identification object (individual access)
+        dev_id_resp = self.client.read_device_identification(read_code=4, object_id=3)
+        if not dev_id_resp:
+            self.fail('ModbusClient.read_device_identification() method failed unexpectedly')
+        else:
+            # return DeviceIdentificationResponse on success
+            self.assertEqual(isinstance(dev_id_resp, DeviceIdentificationResponse), True)
+            # check read data
+            self.assertEqual(len(dev_id_resp.objects_by_id), 1)
+            self.assertEqual(dev_id_resp.vendor_url, vendor_url)
+            self.assertEqual(dev_id_resp.objects_by_id.get(3), vendor_url)
+        # restore default configuration
+        self.server.device_id = None
+
+
+if __name__ == '__main__':
+    unittest.main()

pyModbusTCP-0.3.0/tests/test_server.py

@@ -0,0 +1,43 @@
+""" Test of pyModbusTCP.ModbusServer """
+
+import unittest
+from pyModbusTCP.server import ModbusServer, DeviceIdentification
+
+
+class TestModbusServer(unittest.TestCase):
+    """ ModbusServer tests class. """
+
+    def test_device_identification(self):
+        """Some tests around modbus device identification."""
+        # should raise exception
+        self.assertRaises(TypeError, ModbusServer, device_id=object())
+        # shouldn't raise exception
+        try:
+            ModbusServer(device_id=DeviceIdentification())
+        except Exception as e:
+            self.fail('ModbusServer raised exception "%r" unexpectedly' % e)
+        # init a DeviceIdentification class for test it
+        device_id = DeviceIdentification()
+        # should raise exception
+        with self.assertRaises(TypeError):
+            device_id['obj_name'] = 'anything'
+        with self.assertRaises(TypeError):
+            device_id[0] = 42
+        # shouldn't raise exception
+        try:
+            device_id.vendor_name = b'me'
+            device_id.user_application_name = b'unittest'
+            device_id[0x80] = b'feed'
+        except Exception as e:
+            self.fail('DeviceIdentification raised exception "%r" unexpectedly' % e)
+        # check access by shortcut name (str) or object id (int) return same value
+        self.assertEqual(device_id.vendor_name, device_id[0x00])
+        self.assertEqual(device_id.user_application_name, device_id[0x06])
+        # test __repr__
+        device_id = DeviceIdentification(
+            product_name=b'server', objects_id={42: b'this'})
+        self.assertEqual(repr(device_id), "DeviceIdentification(product_name=b'server', objects_id={42: b'this'})")
+
+
+if __name__ == '__main__':
+    unittest.main()

pyModbusTCP-0.3.0/tests/test_utils.py

@@ -0,0 +1,143 @@
+""" Test of pyModbusTCP.utils """
+
+import unittest
+import math
+from pyModbusTCP.utils import \
+    get_bits_from_int, int2bits, decode_ieee, encode_ieee, \
+    word_list_to_long, words2longs, long_list_to_word, longs2words, \
+    get_2comp, twos_c, get_list_2comp, twos_c_l
+
+
+class TestUtils(unittest.TestCase):
+    """ pyModbusTCP.utils function test class. """
+
+    def test_get_bits_from_int(self):
+        """Test function get_bits_from_int and it's short alias int2bits."""
+        # default bits list size is 16
+        self.assertEqual(len(get_bits_from_int(0)), 16)
+        # for 8 size (positional arg)
+        self.assertEqual(len(get_bits_from_int(0, 8)), 8)
+        # for 32 size (named arg)
+        self.assertEqual(len(get_bits_from_int(0, val_size=32)), 32)
+        # test binary decode
+        self.assertEqual(int2bits(0x0000), [False]*16)
+        self.assertEqual(int2bits(0xffff), [True]*16)
+        self.assertEqual(int2bits(0xf007), [True]*3 + [False]*9 + [True]*4)
+        self.assertEqual(int2bits(6, 4), [False, True, True, False])
+
+    def test_ieee(self):
+        """Test IEEE functions: decode_ieee and encode_ieee."""
+        # test IEEE NaN
+        self.assertTrue(math.isnan(decode_ieee(0x7fc00000)))
+        self.assertEqual(encode_ieee(float('nan')), 0x7fc00000)
+        # test +/- infinity
+        self.assertTrue(math.isinf(decode_ieee(0xff800000)))
+        self.assertTrue(math.isinf(decode_ieee(0x7f800000)))
+        # test big and small values
+        avogad = 6.022140857e+23
+        avo_32 = 0x66ff0c2f
+        avo_64 = 0x44dfe185d2f54b67
+        planck = 6.62606957e-34
+        pla_32 = 0x085c305e
+        pla_64 = 0x390b860bb596a559
+        # IEEE single or double precision format -> float
+        self.assertAlmostEqual(decode_ieee(avo_32), avogad, delta=avogad*1e-7)
+        self.assertAlmostEqual(decode_ieee(avo_64, double=True), avogad)
+        self.assertAlmostEqual(decode_ieee(pla_32), planck)
+        self.assertAlmostEqual(decode_ieee(pla_64, double=True), planck)
+        # float -> IEEE single or double precision format
+        self.assertAlmostEqual(encode_ieee(avogad), avo_32)
+        self.assertAlmostEqual(encode_ieee(avogad, double=True), avo_64)
+        self.assertAlmostEqual(encode_ieee(planck), pla_32)
+        self.assertAlmostEqual(encode_ieee(planck, double=True), pla_64)
+
+    def test_word_list_to_long(self):
+        """Test function word_list_to_long and it 's short alias words2longs."""
+        # empty list, return empty list
+        self.assertEqual(word_list_to_long([]), [])
+        # if len of list is odd ignore last value
+        self.assertEqual(word_list_to_long([0x1, 0x2, 0x3]), [0x10002])
+        # test convert with big and little endian
+        l1 = [0xdead, 0xbeef]
+        l2 = [0xfeed, 0xface, 0xcafe, 0xbeef]
+        big = dict(big_endian=True)
+        nobig = dict(big_endian=False)
+        big64 = dict(big_endian=True, long_long=True)
+        nobig64 = dict(big_endian=False, long_long=True)
+        self.assertEqual(words2longs(l1, **big), [0xdeadbeef])
+        self.assertEqual(words2longs(l2, **big), [0xfeedface, 0xcafebeef])
+        self.assertEqual(words2longs(l1, **nobig), [0xbeefdead])
+        self.assertEqual(words2longs(l2, **nobig), [0xfacefeed, 0xbeefcafe])
+        self.assertEqual(words2longs(l1*2, **big64), [0xdeadbeefdeadbeef])
+        self.assertEqual(words2longs(l2*2, **big64), [0xfeedfacecafebeef]*2)
+        self.assertEqual(words2longs(l1*2, **nobig64), [0xbeefdeadbeefdead])
+        self.assertEqual(words2longs(l2*2, **nobig64), [0xbeefcafefacefeed]*2)
+
+    def test_long_list_to_word(self):
+        """Test function long_list_to_word and short alias longs2words."""
+        # empty list, return empty list
+        self.assertEqual(long_list_to_word([]), [])
+        # test convert with big and little endian
+        l1 = [0xdeadbeef]
+        l1_big = [0xdead, 0xbeef]
+        l1_nobig = [0xbeef, 0xdead]
+        l1_big64 = [0x0000, 0x0000, 0xdead, 0xbeef]
+        l1_nobig64 = [0xbeef, 0xdead, 0x0000, 0x0000]
+        l2 = [0xfeedface, 0xcafebeef]
+        l2_big = [0xfeed, 0xface, 0xcafe, 0xbeef]
+        l2_nobig = [0xface, 0xfeed, 0xbeef, 0xcafe]
+        l3 = [0xfeedfacecafebeef]
+        l3_big64 = [0xfeed, 0xface, 0xcafe, 0xbeef]
+        l3_nobig64 = [0xbeef, 0xcafe, 0xface, 0xfeed]
+        big = dict(big_endian=True)
+        nobig = dict(big_endian=False)
+        big64 = dict(big_endian=True, long_long=True)
+        nobig64 = dict(big_endian=False, long_long=True)
+        self.assertEqual(longs2words(l1, **big), l1_big)
+        self.assertEqual(longs2words(l2, **big), l2_big)
+        self.assertEqual(longs2words(l1, **nobig), l1_nobig)
+        self.assertEqual(longs2words(l2, **nobig), l2_nobig)
+        self.assertEqual(longs2words(l1*2, **big64), l1_big64*2)
+        self.assertEqual(longs2words(l3*2, **big64), l3_big64*2)
+        self.assertEqual(longs2words(l1*4, **nobig64), l1_nobig64*4)
+        self.assertEqual(longs2words(l3*4, **nobig64), l3_nobig64*4)
+
+    def test_get_2comp(self):
+        """Test function get_2comp and it's short alias twos_c."""
+        # check if ValueError exception is raised
+        self.assertRaises(ValueError, get_2comp, 0x10000)
+        self.assertRaises(ValueError, get_2comp, -0x8001)
+        self.assertRaises(ValueError, twos_c, 0x100000000, val_size=32)
+        self.assertRaises(ValueError, twos_c, -0x80000001, val_size=32)
+        # 2's complement of 16bits values (default)
+        self.assertEqual(get_2comp(0x0001), 0x0001)
+        self.assertEqual(get_2comp(0x8000), -0x8000)
+        self.assertEqual(get_2comp(-0x8000), 0x8000)
+        self.assertEqual(get_2comp(0xffff), -0x0001)
+        self.assertEqual(get_2comp(-0x0001), 0xffff)
+        self.assertEqual(get_2comp(-0x00fa), 0xff06)
+        self.assertEqual(get_2comp(0xff06), -0x00fa)
+        # 2's complement of 32bits values
+        self.assertEqual(twos_c(0xfffffff, val_size=32), 0xfffffff)
+        self.assertEqual(twos_c(-1, val_size=32), 0xffffffff)
+        self.assertEqual(twos_c(0xffffffff, val_size=32), -1)
+        self.assertEqual(twos_c(125, val_size=32), 0x0000007d)
+        self.assertEqual(twos_c(0x0000007d, val_size=32), 125)
+        self.assertEqual(twos_c(-250, val_size=32), 0xffffff06)
+        self.assertEqual(twos_c(0xffffff06, val_size=32), -250)
+        self.assertEqual(twos_c(0xfffea2a5, val_size=32), -89435)
+        self.assertEqual(twos_c(-89435, val_size=32), 0xfffea2a5)
+
+    def test_get_list_2comp(self):
+        """Test get_list_2comp and it's short alias twos_c_l."""
+        self.assertEqual(get_list_2comp([0x8000], 16), [-32768])
+        in_l = [0x8000, 0xffff, 0x0042]
+        out_l = [-0x8000, -0x0001, 0x42]
+        self.assertEqual(twos_c_l(in_l, val_size=16), out_l)
+        in_l = [0x8000, 0xffffffff, 0xfffea2a5]
+        out_l = [0x8000, -0x0001, -89435]
+        self.assertEqual(twos_c_l(in_l, val_size=32), out_l)
+
+
+if __name__ == '__main__':
+    unittest.main()