FCC/Test/Devices/Pumps/LanTian_Pump_664_Or_886_Test/MessageTest.cs

using LanTian_Pump_664_Or_886.MessageEntity.Incoming;
using LanTian_Pump_664_Or_886.MessageEntity.Outgoing;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using Edge.Core.Parser.BinaryParser.Util;
using System;
using System.Collections.Generic;
using System.Linq;

namespace LanTian_Pump_664_Or_886_Test
{
    [TestClass]
    public class MessageTest
    {
        public static bool ValueEquals(IEnumerable<byte> array1, IEnumerable<byte> array2)
        {
            if (array1 == null && array2 == null)
            {
                return true;
            }

            if ((array1 == null) || (array2 == null))
            {
                return false;
            }

            if (array1.Count() != array2.Count())
            {
                return false;
            }
            if (array1.Equals(array2))
            {
                return true;
            }
            else
            {
                for (int Index = 0; Index < array1.Count(); Index++)
                {
                    if (!Equals(array1.ElementAt(Index), array2.ElementAt(Index)))
                    {
                        return false;
                    }
                }
            }
            return true;
        }

        [TestMethod]
        public void CaculateXRL_TestMethod1()
        {
            var expect = 0x46;
            var actual = LanTian_Pump_664_Or_886.Parser.GetXRL("F5 01 A5 00 25 00 B2".ToBytes().ToList());
            Assert.AreEqual(true, expect == actual);
        }

        [TestMethod]
        public void CaculateXRL_TestMethod2()
        {
            var expect = 0x3C;
            var actual = LanTian_Pump_664_Or_886.Parser.GetXRL("F5 01 A3 59 B2".ToBytes().ToList());
            Assert.AreEqual(true, expect == actual);
        }

        [TestMethod]
        public void CaculateXRL_TestMethod3()
        {
            var expect = 0x77;
            var actual = LanTian_Pump_664_Or_886.Parser.GetXRL("F5 01 A6 00 00 10 00 B5".ToBytes().ToList());
            Assert.AreEqual(true, expect == actual);
        }

        [TestMethod]
        public void CaculateXRL_TestMethod4()
        {
            var expect = 0x63;
            var actual = LanTian_Pump_664_Or_886.Parser.GetXRL("F5 01 A2 B5".ToBytes().ToList());
            Assert.AreEqual(true, expect == actual);
        }

        [TestMethod]
        public void ChangePriceRequest_TestMethod1()
        {
            var request = new ChangePriceRequest(2500, 3);
            var parser = new LanTian_Pump_664_Or_886.Parser();
            var expect = "F5 01 A5 00 25 00 B2 46".ToBytes();
            var actual = parser.Serialize(request);
            Assert.AreEqual(true, ValueEquals(expect, actual), "actual: 0x" + actual.ToHexLogString());
        }

        [TestMethod]
        public void ChangePriceRequest_TestMethod2()
        {
            var request = new ChangePriceRequest(122534, 3);
            var parser = new LanTian_Pump_664_Or_886.Parser();
            var expect = "F5 01 A5 12 25 34 B2 00".ToBytes();
            var actual = parser.Serialize(request);
            Assert.AreEqual(true, ValueEquals(expect.Take(expect.Length - 1), actual.Take(actual.Length - 1)), "actual: 0x" + actual.ToHexLogString());
        }

        [TestMethod]
        [ExpectedException(typeof(ArgumentException))]
        public void ChangePriceRequest_TestMethod3()
        {
            var request = new ChangePriceRequest(9999999, 3);
            var parser = new LanTian_Pump_664_Or_886.Parser();
            var expect = "F5 01 A5 12 25 34 B2 00".ToBytes();
            var actual = parser.Serialize(request);
            Assert.AreEqual(true, ValueEquals(expect.Take(expect.Length - 1), actual.Take(actual.Length - 1)), "actual: 0x" + actual.ToHexLogString());
        }

        [TestMethod]
        public void ChangePriceResponse_TestMethod1()
        {
            var raw = "F5 01 A3 59 B2 3C".ToBytes();
            var parser = new LanTian_Pump_664_Or_886.Parser();
            var actual = parser.Deserialize(raw) as ChangePriceResponse;
            Assert.AreEqual(true, actual != null);
            Assert.AreEqual(true, actual.Succeed);
        }

        [TestMethod]
        public void ChangePriceResponse_TestMethod2()
        {
            var raw = "F5 01 A3 4E B2 3C".ToBytes();
            var parser = new LanTian_Pump_664_Or_886.Parser();
            var actual = parser.Deserialize(raw) as ChangePriceResponse;
            Assert.AreEqual(true, actual != null);
            Assert.AreEqual(false, actual.Succeed);
        }

        [TestMethod]
        public void ReadPriceRequest_TestMethod1()
        {
            var request = new ReadPriceRequest();
            var parser = new LanTian_Pump_664_Or_886.Parser();
            var expect = "F5 01 A2 B6 60".ToBytes();
            var actual = parser.Serialize(request);
            Assert.AreEqual(true, ValueEquals(expect, actual), "actual: 0x" + actual.ToHexLogString());
        }

        [TestMethod]
        public void ReadPriceResponse_TestMethod1()
        {
            var raw = "F5 01 A5 00 00 05 B6 62".ToBytes();
            var parser = new LanTian_Pump_664_Or_886.Parser();
            var actual = parser.Deserialize(raw) as ReadPriceResponse;
            Assert.AreEqual(true, actual != null);
            Assert.AreEqual(true, actual.Price == 5);
        }

        [TestMethod]
        public void ReadPriceResponse_TestMethod2()
        {
            var raw = "F5 01 A4 00 05 B6 62".ToBytes();
            var parser = new LanTian_Pump_664_Or_886.Parser();
            var actual = parser.Deserialize(raw) as ReadPriceResponse;
            Assert.AreEqual(true, actual != null);
            Assert.AreEqual(true, actual.Price == 5);
        }

        [TestMethod]
        public void ReadPriceResponse_TestMethod3()
        {
            var raw = "F5 01 A4 98 76 B6 62".ToBytes();
            var parser = new LanTian_Pump_664_Or_886.Parser();
            var actual = parser.Deserialize(raw) as ReadPriceResponse;
            Assert.AreEqual(true, actual != null);
            Assert.AreEqual(true, actual.Price == 9876);
        }

        [TestMethod]
        public void ReadPriceResponse_TestMethod4()
        {
            var raw = "F5 01 A5 12 34 56 B6 62".ToBytes();
            var parser = new LanTian_Pump_664_Or_886.Parser();
            var actual = parser.Deserialize(raw) as ReadPriceResponse;
            Assert.AreEqual(true, actual != null);
            Assert.AreEqual(true, actual.Price == 123456);
        }

        [TestMethod]
        public void WriteCloseAheadValveThresholdRequest_TestMethod1()
        {
            var request = new WriteCloseAheadValveThresholdRequest(35);
            var parser = new LanTian_Pump_664_Or_886.Parser();
            var expect = "F5 01 A3 35 D2 30".ToBytes();
            var actual = parser.Serialize(request);
            Assert.AreEqual(true, ValueEquals(expect, actual), "actual: 0x" + actual.ToHexLogString());
        }

        [TestMethod]
        public void WriteCloseAheadValveThresholdRequest_TestMethod2()
        {
            var request = new WriteCloseAheadValveThresholdRequest(99);
            var parser = new LanTian_Pump_664_Or_886.Parser();
            var expect = "F5 01 A3 99 D2 30".ToBytes();
            var actual = parser.Serialize(request);
            Assert.AreEqual(true, ValueEquals(expect.Take(expect.Length - 1), actual.Take(actual.Length - 1)), "actual: 0x" + actual.ToHexLogString());
        }

        [TestMethod]
        public void WriteCloseAheadValveThresholdResponse_TestMethod1()
        {
            var raw = "F5 01 A2 D2 04".ToBytes();
            var parser = new LanTian_Pump_664_Or_886.Parser();
            var actual = parser.Deserialize(raw) as WriteCloseAheadValveThresholdResponse;
            Assert.AreEqual(true, actual != null);
        }

        [TestMethod]
        public void PresetAmountRequest_TestMethod1()
        {
            var request = new PresetAmountRequest(10, 4);
            var parser = new LanTian_Pump_664_Or_886.Parser();
            var expect = "F5 01 A6 00 00 00 10 B5 77".ToBytes();
            var actual = parser.Serialize(request);
            Assert.AreEqual(true, ValueEquals(expect, actual), "actual: 0x" + actual.ToHexLogString());
        }

        [TestMethod]
        public void PresetAmountRequest_TestMethod2()
        {
            var request = new PresetAmountRequest(99887766, 4);
            var parser = new LanTian_Pump_664_Or_886.Parser();
            var expect = "F5 01 A6 99 88 77 66 B5 77".ToBytes();
            var actual = parser.Serialize(request);
            Assert.AreEqual(true, ValueEquals(expect.Take(expect.Length - 1), actual.Take(actual.Length - 1)), "actual: 0x" + actual.ToHexLogString());
        }

        [TestMethod]
        public void PresetAmountRequest_TestMethod3()
        {
            var request = new PresetAmountRequest(998877, 3);
            var parser = new LanTian_Pump_664_Or_886.Parser();
            var expect = "F5 01 A5 99 88 77 B5 77".ToBytes();
            var actual = parser.Serialize(request);
            Assert.AreEqual(true, ValueEquals(expect.Take(expect.Length - 1), actual.Take(actual.Length - 1)), "actual: 0x" + actual.ToHexLogString());
        }

        [TestMethod]
        public void PresetAmountRequest_TestMethod4()
        {
            var request = new PresetAmountRequest(8877, 3);
            var parser = new LanTian_Pump_664_Or_886.Parser();
            var expect = "F5 01 A5 00 88 77 B5 77".ToBytes();
            var actual = parser.Serialize(request);
            Assert.AreEqual(true, ValueEquals(expect.Take(expect.Length - 1), actual.Take(actual.Length - 1)), "actual: 0x" + actual.ToHexLogString());
        }

        [TestMethod]
        public void PresetAmountResponse_TestMethod1()
        {
            var raw = "F5 01 A2 B5 63".ToBytes();
            var parser = new LanTian_Pump_664_Or_886.Parser();
            var actual = parser.Deserialize(raw) as PresetAmountResponse;
            Assert.AreEqual(true, actual != null);
        }

        [TestMethod]
        public void PresetVolumeRequest_TestMethod1()
        {
            var request = new PresetVolumeRequest(1000, 4);
            var parser = new LanTian_Pump_664_Or_886.Parser();
            var expect = "F5 01 A6 00 00 10 00 B9 7B".ToBytes();
            var actual = parser.Serialize(request);
            Assert.AreEqual(true, ValueEquals(expect, actual), "actual: 0x" + actual.ToHexLogString());
        }

        [TestMethod]
        public void PresetVolumeRequest_TestMethod2()
        {
            var request = new PresetVolumeRequest(99887766, 4);
            var parser = new LanTian_Pump_664_Or_886.Parser();
            var expect = "F5 01 A6 99 88 77 66 B9 77".ToBytes();
            var actual = parser.Serialize(request);
            Assert.AreEqual(true, ValueEquals(expect.Take(expect.Length - 1), actual.Take(actual.Length - 1)), "actual: 0x" + actual.ToHexLogString());
        }

        [TestMethod]
        public void PresetVolumeRequest_TestMethod3()
        {
            var request = new PresetVolumeRequest(998877, 3);
            var parser = new LanTian_Pump_664_Or_886.Parser();
            var expect = "F5 01 A5 99 88 77 B9 77".ToBytes();
            var actual = parser.Serialize(request);
            Assert.AreEqual(true, ValueEquals(expect.Take(expect.Length - 1), actual.Take(actual.Length - 1)), "actual: 0x" + actual.ToHexLogString());
        }

        [TestMethod]
        public void PresetVolumeRequest_TestMethod4()
        {
            var request = new PresetVolumeRequest(8877, 3);
            var parser = new LanTian_Pump_664_Or_886.Parser();
            var expect = "F5 01 A5 00 88 77 B9 77".ToBytes();
            var actual = parser.Serialize(request);
            Assert.AreEqual(true, ValueEquals(expect.Take(expect.Length - 1), actual.Take(actual.Length - 1)), "actual: 0x" + actual.ToHexLogString());
        }

        [TestMethod]
        public void PresetVolumeResponse_TestMethod1()
        {
            var raw = "F5 01 A2 B9 6F".ToBytes();
            var parser = new LanTian_Pump_664_Or_886.Parser();
            var actual = parser.Deserialize(raw) as PresetVolumeResponse;
            Assert.AreEqual(true, actual != null);
        }

        [TestMethod]
        public void ReadPumpStateRequest_TestMethod1()
        {
            var request = new ReadPumpStateRequest();
            var parser = new LanTian_Pump_664_Or_886.Parser();
            var expect = "F5 01 A2 D5 03".ToBytes();
            var actual = parser.Serialize(request);
            Assert.AreEqual(true, ValueEquals(expect, actual), "actual: 0x" + actual.ToHexLogString());
        }

        [TestMethod]
        public void ReadPumpStateResponse_TestMethod1()
        {
            var raw = "F5 01 A3 80 D5 02".ToBytes();
            var parser = new LanTian_Pump_664_Or_886.Parser();
            var actual = parser.Deserialize(raw) as ReadPumpStateResponse;
            Assert.AreEqual(true, actual != null);
            Assert.AreEqual(true, actual.NozzleState == ReadPumpStateResponse.NozzleStateEnum.挂枪);
            Assert.AreEqual(true, actual.StartOrStopState == ReadPumpStateResponse.StartOrStopStateEnum.停机);
            Assert.AreEqual(true, actual.ControlState == ReadPumpStateResponse.ControlStateEnum.自控);
            Assert.AreEqual(true, actual.ErrorState == ReadPumpStateResponse.ErrorStateEnum.无错误);
            Assert.AreEqual(true, actual.PaymentState == ReadPumpStateResponse.PaymentStateEnum.无支付请求);
        }

        [TestMethod]
        public void ReadPumpStateResponse_TestMethod2()
        {
            var raw = "F5 01 A3 00 D5 02".ToBytes();
            var parser = new LanTian_Pump_664_Or_886.Parser();
            var actual = parser.Deserialize(raw) as ReadPumpStateResponse;
            Assert.AreEqual(true, actual != null);
            Assert.AreEqual(true, actual.NozzleState == ReadPumpStateResponse.NozzleStateEnum.提枪);
            Assert.AreEqual(true, actual.StartOrStopState == ReadPumpStateResponse.StartOrStopStateEnum.停机);
            Assert.AreEqual(true, actual.ControlState == ReadPumpStateResponse.ControlStateEnum.自控);
            Assert.AreEqual(true, actual.ErrorState == ReadPumpStateResponse.ErrorStateEnum.无错误);
            Assert.AreEqual(true, actual.PaymentState == ReadPumpStateResponse.PaymentStateEnum.无支付请求);
        }

        [TestMethod]
        public void ReadPumpStateResponse_TestMethod3()
        {
            var raw = "F5 01 A3 AB D5 02".ToBytes();
            var parser = new LanTian_Pump_664_Or_886.Parser();
            var actual = parser.Deserialize(raw) as ReadPumpStateResponse;
            Assert.AreEqual(true, actual != null);
            Assert.AreEqual(true, actual.NozzleState == ReadPumpStateResponse.NozzleStateEnum.挂枪);
            Assert.AreEqual(true, actual.StartOrStopState == ReadPumpStateResponse.StartOrStopStateEnum.开机);
            Assert.AreEqual(true, actual.ControlState == ReadPumpStateResponse.ControlStateEnum.受控);
            Assert.AreEqual(true, actual.ErrorState == ReadPumpStateResponse.ErrorStateEnum.传感器错误);
            Assert.AreEqual(true, actual.PaymentState == ReadPumpStateResponse.PaymentStateEnum.POS支付请求);
        }

        [TestMethod]
        public void ReadPumpStateResponse_TestMethod4()
        {
            /*pump stop a fueling*/
            var raw = "F5 01 A3 08 D5 0A".ToBytes();
            var parser = new LanTian_Pump_664_Or_886.Parser();
            var actual = parser.Deserialize(raw) as ReadPumpStateResponse;
            Assert.AreEqual(true, actual != null);
            Assert.AreEqual(true, actual.NozzleState == ReadPumpStateResponse.NozzleStateEnum.提枪);
            Assert.AreEqual(true, actual.StartOrStopState == ReadPumpStateResponse.StartOrStopStateEnum.停机);
            Assert.AreEqual(true, actual.ControlState == ReadPumpStateResponse.ControlStateEnum.受控);
            Assert.AreEqual(true, actual.ErrorState == ReadPumpStateResponse.ErrorStateEnum.无错误);
            Assert.AreEqual(true, actual.PaymentState == ReadPumpStateResponse.PaymentStateEnum.无支付请求);
        }

        [TestMethod]
        public void ReadPumpStateResponse_TestMethod5()
        {
            /*pump stop a fueling*/
            var raw = "F5 01 A3 88 D5 0A".ToBytes();
            var parser = new LanTian_Pump_664_Or_886.Parser();
            var actual = parser.Deserialize(raw) as ReadPumpStateResponse;
            Assert.AreEqual(true, actual != null);
            Assert.AreEqual(true, actual.NozzleState == ReadPumpStateResponse.NozzleStateEnum.挂枪);
            Assert.AreEqual(true, actual.StartOrStopState == ReadPumpStateResponse.StartOrStopStateEnum.停机);
            Assert.AreEqual(true, actual.ControlState == ReadPumpStateResponse.ControlStateEnum.受控);
            Assert.AreEqual(true, actual.ErrorState == ReadPumpStateResponse.ErrorStateEnum.无错误);
            Assert.AreEqual(true, actual.PaymentState == ReadPumpStateResponse.PaymentStateEnum.无支付请求);
        }

        [TestMethod]
        public void ClearTotalizerRequest_TestMethod1()
        {
            var request = new ClearTotalizerRequest();
            var parser = new LanTian_Pump_664_Or_886.Parser();
            var expect = "F5 01 A2 CD 1B".ToBytes();
            var actual = parser.Serialize(request);
            Assert.AreEqual(true, ValueEquals(expect, actual), "actual: 0x" + actual.ToHexLogString());
        }

        [TestMethod]
        public void ClearTotalizerResponse_TestMethod1()
        {
            var raw = "F5 01 A3 59 CD 43".ToBytes();
            var parser = new LanTian_Pump_664_Or_886.Parser();
            var actual = parser.Deserialize(raw) as ClearTotalizerResponse;
            Assert.AreEqual(true, actual != null);
            Assert.AreEqual(true, actual.Succeed);
        }

        [TestMethod]
        public void ClearTotalizerResponse_TestMethod2()
        {
            var raw = "F5 01 A3 4E CD 43".ToBytes();
            var parser = new LanTian_Pump_664_Or_886.Parser();
            var actual = parser.Deserialize(raw) as ClearTotalizerResponse;
            Assert.AreEqual(true, actual != null);
            Assert.AreEqual(false, actual.Succeed);
        }

        [TestMethod]
        public void ReadFuelDataRequest_TestMethod1()
        {
            var request = new ReadFuelDataRequest();
            var parser = new LanTian_Pump_664_Or_886.Parser();
            var expect = "F5 01 A2 D9 0F".ToBytes();
            var actual = parser.Serialize(request);
            Assert.AreEqual(true, ValueEquals(expect, actual), "actual: 0x" + actual.ToHexLogString());
        }

        [TestMethod]
        public void ReadFuelDataResponse_TestMethod1()
        {
            var raw = "F5 01 AA 00 00 00 00 00 00 00 00 D9 07".ToBytes();
            var parser = new LanTian_Pump_664_Or_886.Parser();
            var actual = parser.Deserialize(raw) as ReadFuelDataResponse;
            Assert.AreEqual(true, actual != null);
            Assert.AreEqual(true, actual.Volume == 0);
            Assert.AreEqual(true, actual.Amount == 0);
        }

        [TestMethod]
        public void ReadFuelDataResponse_TestMethod2()
        {
            var raw = "F5 01 AA 12 34 56 78 99 88 77 66 D9 07".ToBytes();
            var parser = new LanTian_Pump_664_Or_886.Parser();
            var actual = parser.Deserialize(raw) as ReadFuelDataResponse;
            Assert.AreEqual(true, actual != null);
            Assert.AreEqual(true, actual.Volume == 12345678);
            Assert.AreEqual(true, actual.Amount == 99887766);
        }

        [TestMethod]
        public void ReadFuelDataResponse_TestMethod3()
        {
            var raw = "F5 01 A8 12 34 56 99 88 77 D9 07".ToBytes();
            var parser = new LanTian_Pump_664_Or_886.Parser();
            var actual = parser.Deserialize(raw) as ReadFuelDataResponse;
            Assert.AreEqual(true, actual != null);
            Assert.AreEqual(true, actual.Volume == 123456);
            Assert.AreEqual(true, actual.Amount == 998877);
        }

        [TestMethod]
        public void ReadTotalizerRequest_TestMethod1()
        {
            var request = new ReadTotalizerRequest();
            var parser = new LanTian_Pump_664_Or_886.Parser();
            var expect = "F5 01 A2 C5 13".ToBytes();
            var actual = parser.Serialize(request);
            Assert.AreEqual(true, ValueEquals(expect, actual), "actual: 0x" + actual.ToHexLogString());
        }

        [TestMethod]
        public void ReadTotalizerResponse_TestMethod1()
        {
            var raw = "F5 01 AE 00 00 00 00 90 00 00 00 00 00 00 15 C5 1A".ToBytes();
            var parser = new LanTian_Pump_664_Or_886.Parser();
            var actual = parser.Deserialize(raw) as ReadTotalizerResponse;
            Assert.AreEqual(true, actual != null);
            Assert.AreEqual(true, actual.VolumeTotalizer == 9000);
            Assert.AreEqual(true, actual.AmountTotalizer == 15);
        }

        [TestMethod]
        public void ReadTotalizerResponse_TestMethod2()
        {
            var raw = "F5 01 AE 10 00 00 00 90 98 76 54 32 10 33 15 C5 1A".ToBytes();
            var parser = new LanTian_Pump_664_Or_886.Parser();
            var actual = parser.Deserialize(raw) as ReadTotalizerResponse;
            Assert.AreEqual(true, actual != null);
            Assert.AreEqual(true, actual.VolumeTotalizer == 100000009098);
            Assert.AreEqual(true, actual.AmountTotalizer == 765432103315);
        }

        [TestMethod]
        public void ReadTotalizerResponse_TestMethod3()
        {
            var raw = "F5 01 AC 12 34 56 78 90 99 88 77 66 55 C5 1A".ToBytes();
            var parser = new LanTian_Pump_664_Or_886.Parser();
            var actual = parser.Deserialize(raw) as ReadTotalizerResponse;
            Assert.AreEqual(true, actual != null);
            Assert.AreEqual(true, actual.VolumeTotalizer == 1234567890);
            Assert.AreEqual(true, actual.AmountTotalizer == 9988776655);
        }

        [TestMethod]
        public void ReadShiftTotalizerRequest_TestMethod1()
        {
            var request = new ReadShiftTotalizerRequest();
            var parser = new LanTian_Pump_664_Or_886.Parser();
            var expect = "F5 01 A2 C7 11".ToBytes();
            var actual = parser.Serialize(request);
            Assert.AreEqual(true, ValueEquals(expect, actual), "actual: 0x" + actual.ToHexLogString());
        }

        [TestMethod]
        public void ReadShiftTotalizerResponse_TestMethod1()
        {
            var raw = "F5 01 AE 00 00 00 00 00 00 00 00 00 00 00 00 C7 1D".ToBytes();
            var parser = new LanTian_Pump_664_Or_886.Parser();
            var actual = parser.Deserialize(raw) as ReadShiftTotalizerResponse;
            Assert.AreEqual(true, actual != null);
            Assert.AreEqual(true, actual.VolumeTotalizer == 0);
            Assert.AreEqual(true, actual.AmountTotalizer == 0);
        }

        [TestMethod]
        public void ReadShiftTotalizerResponse_TestMethod2()
        {
            var raw = "F5 01 AE 10 00 00 00 90 98 76 54 32 10 33 15 C7 1A".ToBytes();
            var parser = new LanTian_Pump_664_Or_886.Parser();
            var actual = parser.Deserialize(raw) as ReadShiftTotalizerResponse;
            Assert.AreEqual(true, actual != null);
            Assert.AreEqual(true, actual.VolumeTotalizer == 100000009098);
            Assert.AreEqual(true, actual.AmountTotalizer == 765432103315);
        }

        [TestMethod]
        public void ReadShiftTotalizerResponse_TestMethod3()
        {
            var raw = "F5 01 AC 12 34 56 78 90 99 88 77 66 55 C7 1A".ToBytes();
            var parser = new LanTian_Pump_664_Or_886.Parser();
            var actual = parser.Deserialize(raw) as ReadShiftTotalizerResponse;
            Assert.AreEqual(true, actual != null);
            Assert.AreEqual(true, actual.VolumeTotalizer == 1234567890);
            Assert.AreEqual(true, actual.AmountTotalizer == 9988776655);
        }

        [TestMethod]
        public void OpenRequest_TestMethod1()
        {
            var request = new OpenRequest();
            var parser = new LanTian_Pump_664_Or_886.Parser();
            var expect = "F5 01 A2 C3 15".ToBytes();
            var actual = parser.Serialize(request);
            Assert.AreEqual(true, ValueEquals(expect, actual), "actual: 0x" + actual.ToHexLogString());
        }

        [TestMethod]
        public void OpenResponse_TestMethod1()
        {
            var raw = "F5 01 A3 4E C3 4D".ToBytes();
            var parser = new LanTian_Pump_664_Or_886.Parser();
            var actual = parser.Deserialize(raw) as OpenResponse;
            Assert.AreEqual(true, actual != null);
            Assert.AreEqual(false, actual.Succeed);
        }

        [TestMethod]
        public void OpenResponse_TestMethod2()
        {
            var raw = "F5 01 A3 59 C3 4D".ToBytes();
            var parser = new LanTian_Pump_664_Or_886.Parser();
            var actual = parser.Deserialize(raw) as OpenResponse;
            Assert.AreEqual(true, actual != null);
            Assert.AreEqual(true, actual.Succeed);
        }

        [TestMethod]
        public void CloseRequest_TestMethod1()
        {
            var request = new CloseRequest();
            var parser = new LanTian_Pump_664_Or_886.Parser();
            var expect = "F5 01 A2 CA 1C".ToBytes();
            var actual = parser.Serialize(request);
            Assert.AreEqual(true, ValueEquals(expect, actual), "actual: 0x" + actual.ToHexLogString());
        }

        [TestMethod]
        public void CloseResponse_TestMethod1()
        {
            var raw = "F5 01 A2 CA 1C".ToBytes();
            var parser = new LanTian_Pump_664_Or_886.Parser();
            var actual = parser.Deserialize(raw) as CloseResponse;
            Assert.AreEqual(true, actual != null);
        }

        [TestMethod]
        public void AcquireControlRequest_TestMethod1()
        {
            var request = new AcquireControlRequest();
            var parser = new LanTian_Pump_664_Or_886.Parser();
            var expect = "F5 01 A2 E5 33".ToBytes();
            var actual = parser.Serialize(request);
            Assert.AreEqual(true, ValueEquals(expect, actual), "actual: 0x" + actual.ToHexLogString());
        }

        [TestMethod]
        public void AcquireControlResponse_TestMethod1()
        {
            var raw = "F5 01 A2 E5 33".ToBytes();
            var parser = new LanTian_Pump_664_Or_886.Parser();
            var actual = parser.Deserialize(raw) as AcquireControlResponse;
            Assert.AreEqual(true, actual != null);
        }

        [TestMethod]
        public void AcquireReturnControlRequest_TestMethod1()
        {
            var request = new AcquireReturnControlRequest();
            var parser = new LanTian_Pump_664_Or_886.Parser();
            var expect = "F5 01 A2 E7 31".ToBytes();
            var actual = parser.Serialize(request);
            Assert.AreEqual(true, ValueEquals(expect, actual), "actual: 0x" + actual.ToHexLogString());
        }

        [TestMethod]
        public void AcquireReturnControlResponse_TestMethod1()
        {
            var raw = "F5 01 A2 E7 31".ToBytes();
            var parser = new LanTian_Pump_664_Or_886.Parser();
            var actual = parser.Deserialize(raw) as AcquireReturnControlResponse;
            Assert.AreEqual(true, actual != null);
        }

        [TestMethod]
        public void ClearShiftTotalizerRequest_TestMethod1()
        {
            var request = new ClearShiftTotalizerRequest();
            var parser = new LanTian_Pump_664_Or_886.Parser();
            /* looks like this sample from doc isn't correct, the XRL byte isn't correct, but still leave it here*/
            var expect = "F5 01 A2 EA 02".ToBytes();
            var actual = parser.Serialize(request);
            Assert.AreEqual(true, ValueEquals(expect, actual), "actual: 0x" + actual.ToHexLogString());
        }

        [TestMethod]
        public void ClearShiftTotalizerResponse_TestMethod1()
        {
            var raw = "F5 01 A2 EA 02".ToBytes();
            var parser = new LanTian_Pump_664_Or_886.Parser();
            var actual = parser.Deserialize(raw) as ClearShiftTotalizerResponse;
            Assert.AreEqual(true, actual != null);
        }

        [TestMethod]
        public void SuspendFuelRequest_TestMethod1()
        {
            var request = new SuspendFuelRequest();
            var parser = new LanTian_Pump_664_Or_886.Parser();
            var expect = "F5 01 A2 BA 6C".ToBytes();
            var actual = parser.Serialize(request);
            Assert.AreEqual(true, ValueEquals(expect, actual), "actual: 0x" + actual.ToHexLogString());
        }

        [TestMethod]
        public void SuspendFuelResponse_TestMethod1()
        {
            var raw = "F5 01 A2 BA 6C".ToBytes();
            var parser = new LanTian_Pump_664_Or_886.Parser();
            var actual = parser.Deserialize(raw) as SuspendFuelResponse;
            Assert.AreEqual(true, actual != null);
        }

        [TestMethod]
        public void ResumeFuelRequest_TestMethod1()
        {
            var request = new ResumeFuelRequest();
            var parser = new LanTian_Pump_664_Or_886.Parser();
            var expect = "F5 01 A2 B3 65".ToBytes();
            var actual = parser.Serialize(request);
            Assert.AreEqual(true, ValueEquals(expect, actual), "actual: 0x" + actual.ToHexLogString());
        }

        [TestMethod]
        public void ResumeFuelResponse_TestMethod1()
        {
            var raw = "F5 01 A2 B3 65".ToBytes();
            var parser = new LanTian_Pump_664_Or_886.Parser();
            var actual = parser.Deserialize(raw) as ResumeFuelResponse;
            Assert.AreEqual(true, actual != null);
        }
    }
}