Пример #1
0
        public void ReadResponse()
        {
            MockRepository     mocks     = new MockRepository();
            ModbusRtuTransport transport =
                mocks.PartialMock <ModbusRtuTransport>(MockRepository.GenerateStub <IStreamResource>());

            Expect.Call(transport.Read(ModbusRtuTransport.ResponseFrameStartLength))
            .Return(new byte[] { 1, 1, 1, 0 });

            Expect.Call(transport.Read(2))
            .Return(new byte[] { 81, 136 });

            mocks.ReplayAll();

            ReadCoilsInputsResponse response =
                transport.ReadResponse <ReadCoilsInputsResponse>() as ReadCoilsInputsResponse;

            Assert.IsNotNull(response);
            ReadCoilsInputsResponse expectedResponse = new ReadCoilsInputsResponse(Modbus.ReadCoils, 1, 1,
                                                                                   new DiscreteCollection(false));

            Assert.AreEqual(response.MessageFrame, expectedResponse.MessageFrame);

            mocks.VerifyAll();
        }
Пример #2
0
        public void ReadResponseSlaveException()
        {
            var factory = new ModbusFactory();
            var mock    = new Mock <ModbusRtuTransport>(StreamResource, factory, NullModbusLogger.Instance)
            {
                CallBase = true
            };
            ModbusRtuTransport transport = mock.Object;

            byte[] messageFrame = { 0x01, 0x81, 0x02 };
            byte[] crc          = ModbusUtility.CalculateCrc(messageFrame);

            mock.Setup(t => t.Read(ModbusRtuTransport.ResponseFrameStartLength))
            .Returns(Enumerable.Concat(messageFrame, new byte[] { crc[0] }).ToArray());

            mock.Setup(t => t.Read(1))
            .Returns(new byte[] { crc[1] });

            IModbusMessage response = transport.ReadResponse <ReadCoilsInputsResponse>();

            Assert.IsType <SlaveExceptionResponse>(response);

            var expectedResponse = new SlaveExceptionResponse(0x01, 0x81, 0x02);

            Assert.Equal(expectedResponse.MessageFrame, response.MessageFrame);

            mock.VerifyAll();
        }
        public void ReadResponseSlaveException()
        {
            MockRepository     mocks     = new MockRepository();
            ModbusRtuTransport transport = mocks.PartialMock <ModbusRtuTransport>(MockRepository.GenerateStub <IStreamResource>());

            byte[] messageFrame = { 0x01, 0x81, 0x02 };
            byte[] crc          = ModbusUtility.CalculateCrc(messageFrame);

            Expect.Call(transport.Read(ModbusRtuTransport.ResponseFrameStartLength))
            .Return(messageFrame.Concat(SequenceUtility.ToSequence(crc[0])).ToArray());

            Expect.Call(transport.Read(1))
            .Return(new byte[] { crc[1] });

            mocks.ReplayAll();

            Assert.IsTrue(transport.ReadResponse <ReadCoilsInputsResponse>() is SlaveExceptionResponse);

            mocks.VerifyAll();
        }
        public void ReadResponseSlaveExceptionWithErroneousLrc()
        {
            MockRepository     mocks     = new MockRepository();
            ModbusRtuTransport transport = mocks.PartialMock <ModbusRtuTransport>(MockRepository.GenerateStub <IStreamResource>());

            byte[] messageFrame = { 0x01, 0x81, 0x02 };
            // invalid crc
            byte[] crc = { 0x9, 0x9 };

            Expect.Call(transport.Read(ModbusRtuTransport.ResponseFrameStartLength))
            .Return(messageFrame.Concat(crc[0].ToSequence()).ToArray());

            Expect.Call(transport.Read(1))
            .Return(new byte[] { crc[1] });

            mocks.ReplayAll();

            transport.ReadResponse <ReadCoilsInputsResponse>();

            mocks.VerifyAll();
        }
Пример #5
0
        public void ReadResponse()
        {
            var factory = new ModbusFactory();
            var mock    = new Mock <ModbusRtuTransport>(StreamResource, factory, NullModbusLogger.Instance)
            {
                CallBase = true
            };
            ModbusRtuTransport transport = mock.Object;

            mock.Setup(t => t.Read(ModbusRtuTransport.ResponseFrameStartLength)).Returns(new byte[] { 1, 1, 1, 0 });
            mock.Setup(t => t.Read(2)).Returns(new byte[] { 81, 136 });

            IModbusMessage response = transport.ReadResponse <ReadCoilsInputsResponse>();

            Assert.IsType <ReadCoilsInputsResponse>(response);

            var expectedResponse = new ReadCoilsInputsResponse(ModbusFunctionCodes.ReadCoils, 1, 1, new DiscreteCollection(false));

            Assert.Equal(expectedResponse.MessageFrame, response.MessageFrame);

            mock.VerifyAll();
        }
Пример #6
0
        public void ReadResponseSlaveExceptionWithErroneousLrc()
        {
            var factory = new ModbusFactory();
            var mock    = new Mock <ModbusRtuTransport>(StreamResource, factory, NullModbusLogger.Instance)
            {
                CallBase = true
            };
            ModbusRtuTransport transport = mock.Object;

            byte[] messageFrame = { 0x01, 0x81, 0x02 };

            // invalid crc
            byte[] crc = { 0x9, 0x9 };

            mock.Setup(t => t.Read(ModbusRtuTransport.ResponseFrameStartLength))
            .Returns(Enumerable.Concat(messageFrame, new byte[] { crc[0] }).ToArray());

            mock.Setup(t => t.Read(1))
            .Returns(new byte[] { crc[1] });

            Assert.Throws <IOException>(() => transport.ReadResponse <ReadCoilsInputsResponse>());

            mock.VerifyAll();
        }