FCC/Test/Devices/Pumps/ZheJiangLanfeng_Pump_Test/MessageUnitTest.cs

using Edge.Core.Parser.BinaryParser.Util;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System.Collections.Generic;
using System.Linq;
using ZheJiangLanfeng_Pump;
using ZheJiangLanfeng_Pump.MessageEntity;
using static ZheJiangLanfeng_Pump.MessageBase;

namespace ZheJiangLanfeng_Pump_Test
{
    [TestClass]
    public class MessageUnitTest
    {
        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 QueryStateRequestTestMethod1()
        {
            var request = new QueryStateRequest(1);
            var parser = new Parser();
            var actual = parser.Serialize(request);
            //          0x01 00 B8 00 00 00 00 00 00 00 00 48
            var expect = "A5 00 B8 00 00 00 00 00 00 00 00 48".ToBytes();
            Assert.AreEqual(true, ValueEquals(actual, expect), "0x" + actual.ToHexLogString());
        }

        [TestMethod]
        public void QueryStateRequestTestMethod2()
        {
            var request = new QueryStateRequest(0xA5);
            var parser = new Parser();
            var actual = parser.Serialize(request);
            //          0x01 00 B8 00 00 00 00 00 00 00 00 48
            var expect = "A5 00 B8 00 00 00 00 00 00 00 00 48".ToBytes();
            Assert.AreEqual(true, ValueEquals(actual, expect), "0x" + actual.ToHexLogString());
        }

        [TestMethod]
        public void ControlDispenserRequestTestMethod1()
        {
            var request = new ControlDispenserRequest(3);
            var parser = new Parser();
            var actual = parser.Serialize(request);
            //          0x01 00 B8 00 00 00 00 00 00 00 00 48
            var expect = "A5 00 A0 00 00 00 00 00 00 00 00 60".ToBytes();
            Assert.AreEqual(true, ValueEquals(actual, expect), "0x" + actual.ToHexLogString());
        }

        [TestMethod]
        public void UncontrolDispenserRequestTestMethod1()
        {
            var request = new UncontrolDispenserRequest(5);
            var parser = new Parser();
            var actual = parser.Serialize(request);
            //          0x01 00 B8 00 00 00 00 00 00 00 00 48
            var expect = "A5 00 B0 00 00 00 00 00 00 00 00 50".ToBytes();
            Assert.AreEqual(true, ValueEquals(actual, expect), "0x" + actual.ToHexLogString());
        }

        [TestMethod]
        public void FuelingRequestTestMethod1()
        {
            var request = new FuelingRequest(5);
            var parser = new Parser();
            var actual = parser.Serialize(request);
            //          0x01 00 B8 00 00 00 00 00 00 00 00 48
            var expect = "A5 00 A1 00 00 00 00 00 00 00 00 5F".ToBytes();
            Assert.AreEqual(true, ValueEquals(actual, expect), "0x" + actual.ToHexLogString());
        }

        [TestMethod]
        public void StopRequestTestMethod1()
        {
            var request = new StopRequest(10);
            var parser = new Parser();
            var actual = parser.Serialize(request);
            //          0x01 00 B8 00 00 00 00 00 00 00 00 48
            var expect = "A5 00 B1 00 00 00 00 00 00 00 00 4F".ToBytes();
            Assert.AreEqual(true, ValueEquals(actual, expect), "0x" + actual.ToHexLogString());
        }

        [TestMethod]
        public void FuelingWithFixedCashRequestTestMethod1()
        {
            var request = new FuelingWithFixedCashRequest(10, 12.21m);
            var parser = new Parser();
            var actual = parser.Serialize(request);
            //          0x01 00 B8 00 00 00 00 00 00 00 00 48
            var expect = "A5 00 A2 00 12 21 00 00 00 00 00 2B".ToBytes();
            Assert.AreEqual(true, ValueEquals(actual, expect), "0x" + actual.ToHexLogString());
        }

        [TestMethod]
        public void FuelingWithFixedCashRequestTestMethod2()
        {
            var request = new FuelingWithFixedCashRequest(10, 1234.56m);
            var parser = new Parser();
            var actual = parser.Serialize(request);
            //          0x01 00 B8 00 00 00 00 00 00 00 00 48
            var expect = "A5 00 A2 12 34 56 00 00 00 00 00 C2".ToBytes();
            Assert.AreEqual(true, ValueEquals(actual, expect), "0x" + actual.ToHexLogString());
        }

        [TestMethod]
        public void FuelingWithFixedCashRequestTestMethod3()
        {
            var request = new FuelingWithFixedCashRequest(10, 1234m);
            var parser = new Parser();
            var actual = parser.Serialize(request);
            //          0x01 00 B8 00 00 00 00 00 00 00 00 48
            var expect = "A5 00 A2 12 34 00 00 00 00 00 00 18".ToBytes();
            Assert.AreEqual(true, ValueEquals(actual, expect), "0x" + actual.ToHexLogString());
        }

        [TestMethod]
        public void FuelingWithFixedCashRequestTestMethod4()
        {
            var request = new FuelingWithFixedCashRequest(10, 12m);
            var parser = new Parser();
            var actual = parser.Serialize(request);
            //          0x01 00 B8 00 00 00 00 00 00 00 00 48
            var expect = "A5 00 A2 00 12 00 00 00 00 00 00 4C".ToBytes();
            Assert.AreEqual(true, ValueEquals(actual, expect), "0x" + actual.ToHexLogString());
        }

        [TestMethod]
        public void SettingPriceRequestTestMethod1()
        {
            var request = new SettingPriceRequest(10, 12m);
            var parser = new Parser();
            var actual = parser.Serialize(request);
            //          0x01 00 B8 00 00 00 00 00 00 00 00 48
            var expect = "A5 00 A4 12 00 00 00 00 00 00 00 4A".ToBytes();
            Assert.AreEqual(true, ValueEquals(actual, expect), "0x" + actual.ToHexLogString());
        }

        [TestMethod]
        public void SettingPriceRequestTestMethod2()
        {
            var request = new SettingPriceRequest(10, 12.21m);
            var parser = new Parser();
            var actual = parser.Serialize(request);
            var expect = "A5 00 A4 12 21 00 00 00 00 00 00 29".ToBytes();
            Assert.AreEqual(true, ValueEquals(actual, expect), "0x" + actual.ToHexLogString());
        }

        [TestMethod]
        public void SettingPriceRequestTestMethod3()
        {
            var request = new SettingPriceRequest(10, 7.89m);
            var parser = new Parser();
            var actual = parser.Serialize(request);
            var expect = "A5 00 A4 07 89 00 00 00 00 00 00 CC".ToBytes();
            Assert.AreEqual(true, ValueEquals(actual, expect), "0x" + actual.ToHexLogString());
        }

        [TestMethod]
        public void SettingPreValveRequestTestMethod1()
        {
            var request = new SettingPreValveRequest(10, 0.98m);
            var parser = new Parser();
            var actual = parser.Serialize(request);
            var expect = "A5 00 A6 98 00 00 00 00 00 00 00 C2".ToBytes();
            Assert.AreEqual(true, ValueEquals(actual, expect), "0x" + actual.ToHexLogString());
        }

        [TestMethod]
        public void SettingPreValveRequestTestMethod2()
        {
            var request = new SettingPreValveRequest(10, 0.9m);
            var parser = new Parser();
            var actual = parser.Serialize(request);
            var expect = "A5 00 A6 90 00 00 00 00 00 00 00 CA".ToBytes();
            Assert.AreEqual(true, ValueEquals(actual, expect), "0x" + actual.ToHexLogString());
        }

        [TestMethod]
        public void SettingPreValveRequestTestMethod3()
        {
            var request = new SettingPreValveRequest(10, 0.09m);
            var parser = new Parser();
            var actual = parser.Serialize(request);
            var expect = "A5 00 A6 09 00 00 00 00 00 00 00 51".ToBytes();
            Assert.AreEqual(true, ValueEquals(actual, expect), "0x" + actual.ToHexLogString());
        }


        [TestMethod]
        public void QueryStateResponseTestMethod1()
        {
            var raw = "0A 00     12 34     56 78 90     11 22 33    61     CC".ToBytes();
            var parser = new Parser();
            var actual = parser.Deserialize(raw) as QueryStateResponse;
            Assert.AreEqual(true, actual != null);
            Assert.AreEqual(0x5A, actual.NzlNo);
            Assert.AreEqual(12.34m, actual.GetPrice());
            Assert.AreEqual(5678.90m, actual.GetCash());
            Assert.AreEqual(1122.33m, actual.GetLiter());
            var states = actual.GetStates();
            Assert.AreEqual(true, states.Contains(QueryStateResponse.StateEnum.StopFuelingAndStandBy));
        }

        [TestMethod]
        public void QueryStateResponseTestMethod2()
        {
            var raw = "0A 00     12 34     56 78 90     11 22 33    E1     CC".ToBytes();
            var parser = new Parser();
            var actual = parser.Deserialize(raw) as QueryStateResponse;
            Assert.AreEqual(true, actual != null);
            Assert.AreEqual(0x5A, actual.NzlNo);
            Assert.AreEqual(12.34m, actual.GetPrice());
            Assert.AreEqual(5678.90m, actual.GetCash());
            Assert.AreEqual(1122.33m, actual.GetLiter());
            var states = actual.GetStates();
            Assert.AreEqual(true, states.Contains(QueryStateResponse.StateEnum.LiftedNzl));
        }

        [TestMethod]
        public void QueryStateResponseTestMethod3()
        {
            var raw = "5A 00     07 34     03 00 00     11 22 33    E2     CC".ToBytes();
            var parser = new Parser();
            var actual = parser.Deserialize(raw) as QueryStateResponse;
            Assert.AreEqual(true, actual != null);
            Assert.AreEqual(0x5A, actual.NzlNo);
            Assert.AreEqual(7.34m, actual.GetPrice());
            Assert.AreEqual(300, actual.GetCash());
            Assert.AreEqual(1122.33m, actual.GetLiter());
            var states = actual.GetStates();
            Assert.AreEqual(true, states.Contains(QueryStateResponse.StateEnum.Fueling));
        }

        [TestMethod]
        public void QueryStateResponseTestMethod4()
        {
            var raw = "5A 00 01 00 00 00 00 00 00 00 41 BE".ToBytes();
            var parser = new Parser();
            var actual = parser.Deserialize(raw) as QueryStateResponse;
            Assert.AreEqual(true, actual != null);
            Assert.AreEqual(0x5A, actual.NzlNo);
        }

        [TestMethod]
        public void QueryShiftSumResponseTestMethod1()
        {
            var raw = "0A 00     A9       12 34 56 78     90 87 65 43      CC".ToBytes();
            var parser = new Parser();
            var actual = parser.Deserialize(raw) as QueryShiftSumResponse;
            Assert.AreEqual(true, actual != null);
            Assert.AreEqual(0x5A, actual.NzlNo);
            Assert.AreEqual(12345678m, actual.RawLiterSum);
            Assert.AreEqual(90876543m, actual.RawMoneySum);
            Assert.AreEqual(123456.78m, actual.GetLiterSum());
            Assert.AreEqual(908765.43m, actual.GetMoneySum());
        }

        [TestMethod]
        public void QueryShiftSumResponseTestMethod2()
        {
            var raw = "0A 00     A9       12 34 56 00     00 87 65 43      CC".ToBytes();
            var parser = new Parser();
            var actual = parser.Deserialize(raw) as QueryShiftSumResponse;
            Assert.AreEqual(true, actual != null);
            Assert.AreEqual(0x5A, actual.NzlNo);
            Assert.AreEqual(12345600m, actual.RawLiterSum);
            Assert.AreEqual(876543m, actual.RawMoneySum);
            Assert.AreEqual(123456m, actual.GetLiterSum());
            Assert.AreEqual(8765.43m, actual.GetMoneySum());
        }

        [TestMethod]
        public void QueryTotalCashResponseTestMethod1()
        {
            var raw = "0A 00     AC       12 34 56 78     90 87 65 43      CC".ToBytes();
            var parser = new Parser();
            var actual = parser.Deserialize(raw) as QueryTotalCashResponse;
            Assert.AreEqual(true, actual != null);
            Assert.AreEqual(0x5A, actual.NzlNo);
            Assert.AreEqual(1234567890876543m, actual.RawMoneySum);
            Assert.AreEqual(12345678908765.43m, actual.GetMoneySum());
        }

        [TestMethod]
        public void QueryTotalCashResponseTestMethod2()
        {
            var raw = "0A 00     AC       00 00 56 78     00 87 65 43      CC".ToBytes();
            var parser = new Parser();
            var actual = parser.Deserialize(raw) as QueryTotalCashResponse;
            Assert.AreEqual(true, actual != null);
            Assert.AreEqual(0x5A, actual.NzlNo);
            Assert.AreEqual(567800876543m, actual.RawMoneySum);
            Assert.AreEqual(5678008765.43m, actual.GetMoneySum());
        }

        [TestMethod]
        public void QueryTotalCashResponseTestMethod3()
        {
            var raw = "0A 00     AC       00 00 56 78     00 87 00 00      CC".ToBytes();
            var parser = new Parser();
            var actual = parser.Deserialize(raw) as QueryTotalCashResponse;
            Assert.AreEqual(true, actual != null);
            Assert.AreEqual(0x5A, actual.NzlNo);
            Assert.AreEqual(567800870000m, actual.RawMoneySum);
            Assert.AreEqual(5678008700m, actual.GetMoneySum());
        }



        [TestMethod]
        public void QueryTotalLiterResponseTestMethod1()
        {
            var raw = "0A 00     AD       12 34 56 78     90 87 65 43      CC".ToBytes();
            var parser = new Parser();
            var actual = parser.Deserialize(raw) as QueryTotalLiterResponse;
            Assert.AreEqual(true, actual != null);
            Assert.AreEqual(0x5A, actual.NzlNo);
            Assert.AreEqual(1234567890876543m, actual.RawLiterSum);
            Assert.AreEqual(12345678908765.43m, actual.GetLiterSum());
        }

        [TestMethod]
        public void QueryTotalLiterResponseTestMethod2()
        {
            var raw = "0A 00     AD       00 00 56 78     00 87 65 43      CC".ToBytes();
            var parser = new Parser();
            var actual = parser.Deserialize(raw) as QueryTotalLiterResponse;
            Assert.AreEqual(true, actual != null);
            Assert.AreEqual(0x5A, actual.NzlNo);
            Assert.AreEqual(567800876543m, actual.RawLiterSum);
            Assert.AreEqual(5678008765.43m, actual.GetLiterSum());
        }

        [TestMethod]
        public void QueryTotalLiterResponseTestMethod3()
        {
            var raw = "0A 00     AD       00 00 56 78     00 87 00 00      CC".ToBytes();
            var parser = new Parser();
            var actual = parser.Deserialize(raw) as QueryTotalLiterResponse;
            Assert.AreEqual(true, actual != null);
            Assert.AreEqual(0x5A, actual.NzlNo);
            Assert.AreEqual(567800870000m, actual.RawLiterSum);
            Assert.AreEqual(5678008700m, actual.GetLiterSum());
        }

        [TestMethod]
        public void SimpleGenericResponseTestMethod3()
        {
            var raw = "5A 00      A2      00 00 00 00 00 00 00    E1      7D".ToBytes();
            var parser = new Parser();
            var actual = parser.Deserialize(raw) as SimpleGenericResponse;
            Assert.AreEqual(true, actual != null);
            Assert.AreEqual(0x5A, actual.NzlNo);
            Assert.AreEqual(CommandEnum.FuelingWithFixedCash, actual.Command);
        }

        [TestMethod]
        public void ShouldCutTest1()
        {
            var cutter = new ZhongSheng_NonIC_Pump.MessageCutter();
            int onMsgCutCalledTimes = 0;
            int onInvalidMsgCalledTimes = 0;
            List<byte[]> messages = new List<byte[]>();
            cutter.OnMessageCut += (s, a) =>
            {
                onMsgCutCalledTimes++;
                messages.Add(cutter.Message);
            };
            cutter.OnInvalidMessageRead += (e, f) =>
            {
                onInvalidMsgCalledTimes++;
            };

            var rawValid = "5A 00 01 00 00 00 00 00 00 00 61 9E".ToBytes();
            cutter.Feed(rawValid);
            Assert.AreEqual(true, onMsgCutCalledTimes == 1);
            Assert.AreEqual(true, messages.Count == 1);
            Assert.AreEqual(true, ValueEquals(messages[0], rawValid));
            Assert.AreEqual(true, onInvalidMsgCalledTimes == 0);
        }

        [TestMethod]
        public void ShouldCutTest2()
        {
            var cutter = new ZhongSheng_NonIC_Pump.MessageCutter();
            int onMsgCutCalledTimes = 0;
            int onInvalidMsgCalledTimes = 0;
            List<byte[]> messages = new List<byte[]>();
            cutter.OnMessageCut += (s, a) =>
            {
                onMsgCutCalledTimes++;
                messages.Add(cutter.Message);
            };
            cutter.OnInvalidMessageRead += (e, f) =>
            {
                onInvalidMsgCalledTimes++;
            };

            var rawValid = "5A 00 A2 00 00 00 00 00 00 00 e1 7d     5A 00 01 00 00 00 00 00 00 00 61 9E".ToBytes();
            cutter.Feed(rawValid);
            Assert.AreEqual(true, onMsgCutCalledTimes == 2);
            Assert.AreEqual(true, messages.Count == 2);
            Assert.AreEqual(true, ValueEquals(messages[0], rawValid.Take(12)));
            Assert.AreEqual(true, ValueEquals(messages[1], rawValid.Skip(12).Take(12)));
            Assert.AreEqual(true, onInvalidMsgCalledTimes == 0);
        }

        [TestMethod]
        public void ShouldCutTest3()
        {
            var cutter = new ZhongSheng_NonIC_Pump.MessageCutter();
            int onMsgCutCalledTimes = 0;
            int onInvalidMsgCalledTimes = 0;
            List<byte[]> messages = new List<byte[]>();
            cutter.OnMessageCut += (s, a) =>
            {
                onMsgCutCalledTimes++;
                messages.Add(cutter.Message);
            };
            cutter.OnInvalidMessageRead += (e, f) =>
            {
                onInvalidMsgCalledTimes++;
            };

            var rawValid = "5A 00 A2 00 00 00 00 00 00 00 e1 7d  FF   5A 00 01 00 00 00 00 00 00 00 61 9E".ToBytes();
            cutter.Feed(rawValid);
            Assert.AreEqual(true, onMsgCutCalledTimes == 2);
            Assert.AreEqual(true, messages.Count == 2);
            Assert.AreEqual(true, ValueEquals(messages[0], rawValid.Take(12)));
            Assert.AreEqual(true, ValueEquals(messages[1], rawValid.Skip(13).Take(12)));
            Assert.AreEqual(true, onInvalidMsgCalledTimes == 1);
        }


        [TestMethod]
        public void ShouldCutTest4()
        {
            var cutter = new ZhongSheng_NonIC_Pump.MessageCutter();
            int onMsgCutCalledTimes = 0;
            int onInvalidMsgCalledTimes = 0;
            List<byte[]> bytesMessages = new List<byte[]>();
            List<MessageBase> messages = new List<MessageBase>();
            cutter.OnMessageCut += (s, a) =>
            {
                onMsgCutCalledTimes++;
                bytesMessages.Add(cutter.Message);
                var parser = new Parser();
                var message = parser.Deserialize(cutter.Message) as MessageBase;
                messages.Add(message);
            };
            cutter.OnInvalidMessageRead += (e, f) =>
            {
                onInvalidMsgCalledTimes++;
            };

            var rawValid = "5A 00 A2 00 00 00 00 00 00 00 e1 7d  FF   5A 00 01 00 00 00 00 00 00 00 61 9E".ToBytes();
            cutter.Feed(rawValid);

        }
    }
}