コード例 #1
0
 def testBitReadMessageExecuteSuccess(self):
     ''' Test bit read request encoding '''
     context = MockContext()
     context.validate = lambda a, b, c: True
     requests = [
         ReadCoilsRequest(1, 5),
         ReadDiscreteInputsRequest(1, 5),
     ]
     for request in requests:
         result = request.execute(context)
         self.assertEqual(result.bits, [True] * 5)
コード例 #2
0
 def testBitReadMessageExecuteSuccess(self):
     ''' Test bit read request encoding '''
     context = MockContext()
     context.validate = lambda a,b,c: True
     requests = [
         ReadCoilsRequest(1,5),
         ReadDiscreteInputsRequest(1,5),
     ]
     for request in requests:
         result = request.execute(context)
         self.assertEqual(result.bits, [True] * 5)
コード例 #3
0
 def test_bit_read_message_execute_success(self):
     """ Test bit read request encoding """
     context = MockContext()
     context.validate = lambda a, b, c: True
     requests = [
         ReadCoilsRequest(1, 5),
         ReadDiscreteInputsRequest(1, 5),
     ]
     for request in requests:
         result = request.execute(context)
         self.assertEqual(result.bits, [True] * 5)
コード例 #4
0
    def testWriteSingleRegisterRequest(self):
        context = MockContext()
        request = WriteSingleRegisterRequest(0x00, 0xf0000)
        result = request.execute(context)
        self.assertEqual(result.exception_code, ModbusExceptions.IllegalValue)

        request.value = 0x00ff
        result = request.execute(context)
        self.assertEqual(result.exception_code, ModbusExceptions.IllegalAddress)

        context.valid = True
        result = request.execute(context)
        self.assertEqual(result.function_code, request.function_code)
コード例 #5
0
    def testWriteSingleRegisterRequest(self):
        context = MockContext()
        request = WriteSingleRegisterRequest(0x00, 0xf0000)
        result = request.execute(context)
        self.assertEqual(result.exception_code, ModbusExceptions.IllegalValue)

        request.value = 0x00ff
        result = request.execute(context)
        self.assertEqual(result.exception_code,
                         ModbusExceptions.IllegalAddress)

        context.valid = True
        result = request.execute(context)
        self.assertEqual(result.function_code, request.function_code)
コード例 #6
0
    def testWriteSingleCoilExecute(self):
        context = MockContext(False, default=True)
        request = WriteSingleCoilRequest(2, True)
        result = request.execute(context)
        self.assertEqual(result.exception_code, ModbusExceptions.IllegalAddress)

        context.valid = True
        result = request.execute(context)
        self.assertEqual(result.encode(), "\x00\x02\xff\x00")

        context = MockContext(True, default=False)
        request = WriteSingleCoilRequest(2, False)
        result = request.execute(context)
        self.assertEqual(result.encode(), "\x00\x02\x00\x00")
コード例 #7
0
    def testWriteSingleCoilExecute(self):
        context = MockContext(False, default=True)
        request = WriteSingleCoilRequest(2, True)
        result = request.execute(context)
        self.assertEqual(result.exception_code,
                         ModbusExceptions.IllegalAddress)

        context.valid = True
        result = request.execute(context)
        self.assertEqual(result.encode(), '\x00\x02\xff\x00')

        context = MockContext(True, default=False)
        request = WriteSingleCoilRequest(2, False)
        result = request.execute(context)
        self.assertEqual(result.encode(), '\x00\x02\x00\x00')
コード例 #8
0
    def testReadWriteMultipleRegistersValidate(self):
        context = MockContext()
        context.validate = lambda f,a,c: a == 1
        request = ReadWriteMultipleRegistersRequest(read_address=1,
            read_count=10, write_address=2, write_registers=[0x00])
        response = request.execute(context)
        self.assertEqual(response.exception_code, ModbusExceptions.IllegalAddress)

        context.validate = lambda f,a,c: a == 2
        response = request.execute(context)
        self.assertEqual(response.exception_code, ModbusExceptions.IllegalAddress)

        request.write_byte_count = 0x100
        response = request.execute(context)
        self.assertEqual(response.exception_code, ModbusExceptions.IllegalValue)
コード例 #9
0
    def testReadWriteMultipleRegistersValidate(self):
        context = MockContext()
        context.validate = lambda f,a,c: a == 1
        request = ReadWriteMultipleRegistersRequest(read_address=1,
            read_count=10, write_address=2, write_registers=[0x00])
        response = request.execute(context)
        self.assertEqual(response.exception_code, ModbusExceptions.IllegalAddress)

        context.validate = lambda f,a,c: a == 2
        response = request.execute(context)
        self.assertEqual(response.exception_code, ModbusExceptions.IllegalAddress)

        request.write_byte_count = 0x100
        response = request.execute(context)
        self.assertEqual(response.exception_code, ModbusExceptions.IllegalValue)
コード例 #10
0
 def testReadFifoQueueRequestError(self):
     ''' Test basic bit message encoding/decoding '''
     context = MockContext()
     handle = ReadFifoQueueRequest(0x1234)
     handle.values = [0x00] * 32
     result = handle.execute(context)
     self.assertEqual(result.function_code, 0x98)
コード例 #11
0
 def testReadWriteMultipleRegistersRequest(self):
     context = MockContext(True)
     request = ReadWriteMultipleRegistersRequest(read_address=1,
                                                 read_count=10,
                                                 write_address=1,
                                                 write_registers=[0x00])
     response = request.execute(context)
     self.assertEqual(request.function_code, response.function_code)
コード例 #12
0
    def testWriteMultipleRegisterRequest(self):
        context = MockContext()
        request = WriteMultipleRegistersRequest(0x00, [0x00]*10)
        result = request.execute(context)
        self.assertEqual(result.exception_code, ModbusExceptions.IllegalAddress)

        request.count = 0x05 # bytecode != code * 2
        result = request.execute(context)
        self.assertEqual(result.exception_code, ModbusExceptions.IllegalValue)

        request.count = 0x800 # outside of range
        result = request.execute(context)
        self.assertEqual(result.exception_code, ModbusExceptions.IllegalValue)

        context.valid = True
        request = WriteMultipleRegistersRequest(0x00, [0x00]*10)
        result = request.execute(context)
        self.assertEqual(result.function_code, request.function_code)
コード例 #13
0
    def testWriteMultipleRegisterRequest(self):
        context = MockContext()
        request = WriteMultipleRegistersRequest(0x00, [0x00] * 10)
        result = request.execute(context)
        self.assertEqual(result.exception_code,
                         ModbusExceptions.IllegalAddress)

        request.count = 0x05  # bytecode != code * 2
        result = request.execute(context)
        self.assertEqual(result.exception_code, ModbusExceptions.IllegalValue)

        request.count = 0x800  # outside of range
        result = request.execute(context)
        self.assertEqual(result.exception_code, ModbusExceptions.IllegalValue)

        context.valid = True
        request = WriteMultipleRegistersRequest(0x00, [0x00] * 10)
        result = request.execute(context)
        self.assertEqual(result.function_code, request.function_code)
コード例 #14
0
 def testBitReadMessageExecuteAddressErrors(self):
     ''' Test bit read request encoding '''
     context = MockContext()
     requests = [
         ReadCoilsRequest(1, 5),
         ReadDiscreteInputsRequest(1, 5),
     ]
     for request in requests:
         result = request.execute(context)
         self.assertEqual(ModbusExceptions.IllegalAddress,
                          result.exception_code)
コード例 #15
0
 def test_bit_read_message_execute_address_errors(self):
     """ Test bit read request encoding """
     context = MockContext()
     requests = [
         ReadCoilsRequest(1, 5),
         ReadDiscreteInputsRequest(1, 5),
     ]
     for request in requests:
         result = request.execute(context)
         self.assertEqual(
             ModbusExceptions.IllegalAddress, result.exception_code
         )
コード例 #16
0
 def testRegisterReadRequestsExecute(self):
     '''
     This tests that the register request messages
     will break on counts that are out of range
     '''
     context = MockContext(True)
     requests = [
         ReadHoldingRegistersRequest(-1, 5),
         ReadInputRegistersRequest(-1, 5),
     ]
     for request in requests:
         response = request.execute(context)
         self.assertEqual(request.function_code, response.function_code)
コード例 #17
0
    def testWriteMultipleCoilsExecute(self):
        context = MockContext(False)
        # too many values
        request = WriteMultipleCoilsRequest(2, FakeList(0x123456))
        result = request.execute(context)
        self.assertEqual(result.exception_code, ModbusExceptions.IllegalValue)

        # bad byte count
        request = WriteMultipleCoilsRequest(2, [0x00] * 4)
        request.byte_count = 0x00
        result = request.execute(context)
        self.assertEqual(result.exception_code, ModbusExceptions.IllegalValue)

        # does not validate
        context.valid = False
        request = WriteMultipleCoilsRequest(2, [0x00] * 4)
        result = request.execute(context)
        self.assertEqual(result.exception_code, ModbusExceptions.IllegalAddress)

        # validated request
        context.valid = True
        result = request.execute(context)
        self.assertEqual(result.encode(), "\x00\x02\x00\x04")
コード例 #18
0
    def testReadFifoQueueRequest(self):
        ''' Test basic bit message encoding/decoding '''
        context = MockContext()
        handle = ReadFifoQueueRequest(0x1234)
        result = handle.execute(context)
        self.assertTrue(isinstance(result, ReadFifoQueueResponse))

        handle.address = -1
        result = handle.execute(context)
        self.assertEqual(ModbusExceptions.IllegalValue, result.exception_code)

        handle.values = [0x00] * 33
        result = handle.execute(context)
        self.assertEqual(ModbusExceptions.IllegalValue, result.exception_code)
コード例 #19
0
    def testWriteMultipleCoilsExecute(self):
        context = MockContext(False)
        # too many values
        request = WriteMultipleCoilsRequest(2, FakeList(0x123456))
        result = request.execute(context)
        self.assertEqual(result.exception_code, ModbusExceptions.IllegalValue)

        # bad byte count
        request = WriteMultipleCoilsRequest(2, [0x00] * 4)
        request.byte_count = 0x00
        result = request.execute(context)
        self.assertEqual(result.exception_code, ModbusExceptions.IllegalValue)

        # does not validate
        context.valid = False
        request = WriteMultipleCoilsRequest(2, [0x00] * 4)
        result = request.execute(context)
        self.assertEqual(result.exception_code,
                         ModbusExceptions.IllegalAddress)

        # validated request
        context.valid = True
        result = request.execute(context)
        self.assertEqual(result.encode(), '\x00\x02\x00\x04')
コード例 #20
0
    def testMaskWriteRegisterRequestInvalidExecute(self):
        ''' Test write register request execute with invalid data '''
        context = MockContext(valid=False, default=0x0000)
        handle = MaskWriteRegisterRequest(0x0000, -1, 0x1010)
        result = handle.execute(context)
        self.assertEqual(ModbusExceptions.IllegalValue, result.exception_code)

        handle = MaskWriteRegisterRequest(0x0000, 0x0101, -1)
        result = handle.execute(context)
        self.assertEqual(ModbusExceptions.IllegalValue, result.exception_code)

        handle = MaskWriteRegisterRequest(0x0000, 0x0101, 0x1010)
        result = handle.execute(context)
        self.assertEqual(ModbusExceptions.IllegalAddress,
                         result.exception_code)
コード例 #21
0
 def testRegisterReadRequestsValidateErrors(self):
     '''
     This tests that the register request messages
     will break on counts that are out of range
     '''
     context = MockContext()
     requests = [
         ReadHoldingRegistersRequest(-1, 5),
         ReadInputRegistersRequest(-1, 5),
         #ReadWriteMultipleRegistersRequest(-1,5,1,5),
         #ReadWriteMultipleRegistersRequest(1,5,-1,5),
     ]
     for request in requests:
         result = request.execute(context)
         self.assertEqual(ModbusExceptions.IllegalAddress,
                          result.exception_code)
コード例 #22
0
 def testMaskWriteRegisterRequestExecute(self):
     ''' Test write register request valid execution '''
     context = MockContext(valid=True, default=0x0000)
     handle = MaskWriteRegisterRequest(0x0000, 0x0101, 0x1010)
     result = handle.execute(context)
     self.assertTrue(isinstance(result, MaskWriteRegisterResponse))