FCC/Test/Devices/Terminals/GilbarcoDispenserPayTerminal_Test/ProtocolMessageTest.cs

using Dfs.WayneChina.GilbarcoDispenserPayTerminal.MessageEntities.Incoming;
using Dfs.WayneChina.GilbarcoDispenserPayTerminal.MessageEntities.Outgoing;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;

namespace GilbarcoDispenserPayTerminal_Test
{
    [TestClass]
    public class ProtocolMessageTest
    {
        private Dfs.WayneChina.GilbarcoDispenserPayTerminal.Parser parser = new Dfs.WayneChina.GilbarcoDispenserPayTerminal.Parser();

        #region Incoming message binary

        private byte[] serializedCheckCmd = new byte[]
        {
            0xFA,0x23,0xE0,0x45,0x00,0x17,0x30,0x20,0x20,0x08,0x07,0x11,0x15,0x04,0x00,0x01,
            0x10,0x01,0x06,0x23,0x10,0x00,0x00,0x73,0x94
        };

        private byte[] crcWithDoubleFA = new byte[]
        {
            0xFA,0x23,0xE0,0x4A,0x00,0x17,0x30,0x20,0x20,0x08,0x07,0x11,0x18,0x47,0x00,0x01,
            0x10,0x01,0x06,0x23,0x10,0x00,0x00,0xFA,0xFA,0x09
        };

        private byte[] infoCmdNormalBytes = new byte[]
        {
            0xFA,0xE0,0x23,0x49,0x00,0x02,0x31,0x00,0x03,0x8F
        };

        private byte[] infoCmdWithCardBytes = new byte[]
        {
            0xFA,0xE0,0x23,0x48,0x00,0x21,0x31,0x01,0x01,0x01,0x10,0x01,0x02,0x05,0x10,0x10,
            0x00,0x00,0x00,0x00,0x42,0x00,0x00,0xFF,0xD6,0x03,0xCA,0xB5,0x54
        };

        private byte[] infoCmdWithFillingStatusBytes = new byte[]
        {
            0xFA,0xE0,0x23,0x45,0x00,0x13,0x31,0x01,0x02,0x01,0x00,0x00,0x04,0x17,0x00,0x00,
            0xC3,0x02,0x19,0x02,0xAC
        };

        private byte[] transactionDataBytes = new byte[] 
        {
            0xFA,0xE0,0x23,0x45,0x00,0x96,0x32,0x00,0x00,0x1B,0xAD,0x50,0x20,0x20,0x08,0x07,
            0x11,0x14,0x56,0x01,0x02,0x05,0x10,0x10,0x00,0x00,0x00,0x00,0x42,0xFF,0xD5,0xFF,
            0x98,0x00,0x04,0x32,0x02,0xDF,0xE6,0x2D,0x52,0x81,0x00,0x00,0x00,0x00,0x00,0x00,
            0x00,0x00,0x01,0x02,0x10,0x10,0x10,0x09,0x00,0x00,0x00,0x46,0x13,0x01,0x00,0x00,
            0x00,0x46,0x00,0x00,0x09,0x21,0x00,0x00,0x00,0x11,0x01,0x20,0x30,0x00,0x00,0xC8,
            0x02,0x19,0x04,0x01,0xD4,0x1B,0x68,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
            0x00,0x00,0x11,0x62,0x7F,0xEF,0x74,0xA7
        };

        private byte[] transData = new byte[]
        {
            0xFA,0xE0,0x22,0x47,0x00,0x96,0x32,0x00,0x00,0x1B,0xD9,0x50,0x20,0x20,0x08,0x24,
            0x14,0x43,0x32,0x01,0x02,0x05,0x10,0x10,0x00,0x00,0x00,0x00,0x42,0xFF,0xD5,0xE3,
            0x51,0x00,0x02,0x20,0x02,0xE6,0x05,0xF3,0x72,0xE5,0x00,0x00,0x00,0x00,0x00,0x00,
            0x00,0x00,0x01,0x02,0x10,0x10,0x10,0x09,0x00,0x00,0x00,0x46,0x13,0x01,0x00,0x00,
            0x00,0x46,0x00,0x00,0x09,0x39,0x00,0x00,0x00,0x11,0x01,0x20,0x30,0x00,0x00,0x64,
            0x02,0x20,0x04,0x01,0xD5,0x2B,0x6E,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
            0x00,0x00,0x74,0x6A,0x5E,0x20,0x21,0x2D
        };

        private byte[] infoCmdWithDoubleFA = new byte[]
        {
            0xFA,0xE0,0x22,0x5E,0x00,0x02,0x31,0x00,0xD1,0xFA,0xFA
        };

        #endregion

        [TestMethod]
        public void Check_command_serialized_ok()
        {
            CheckCommand checkCommand = new CheckCommand();
            checkCommand.DestinationAddress = 0x23;
            checkCommand.SourceAddress = 0xE0;
            checkCommand.FrameSqNoByte = 0x45;
            checkCommand.Time = 20200807111504;
            checkCommand.BaseBlacklistVersion = 1;
            
            checkCommand.AddBlacklistVersion = 0x10;
            checkCommand.DeleteBlacklistVersion = 1;
            checkCommand.WhitelistVersion = 6;
            checkCommand.PriceVersion = 0x23;
            checkCommand.StationGeneralInfoVersion = 0x10;
            checkCommand.PrivateDataDownloadFlag = 0;
            checkCommand.SoftwareDownloadFlag = 0;

            var bytes = parser.Serialize(checkCommand);
            Assert.IsTrue(ValueEquals(serializedCheckCmd, bytes));
        }

        [TestMethod]
        public void Double_FA_in_crc_is_inserted_ok()
        {
            CheckCommand checkCommand = new CheckCommand();
            checkCommand.DestinationAddress = 0x23;
            checkCommand.SourceAddress = 0xE0;
            checkCommand.FrameSqNoByte = 0x4A;
            checkCommand.Time = 20200807111847;
            checkCommand.BaseBlacklistVersion = 1;

            checkCommand.AddBlacklistVersion = 0x10;
            checkCommand.DeleteBlacklistVersion = 1;
            checkCommand.WhitelistVersion = 6;
            checkCommand.PriceVersion = 0x23;
            checkCommand.StationGeneralInfoVersion = 0x10;
            checkCommand.PrivateDataDownloadFlag = 0;
            checkCommand.SoftwareDownloadFlag = 0;

            var bytes = parser.Serialize(checkCommand);
            Assert.IsTrue(ValueEquals(crcWithDoubleFA, bytes));
        }

        [TestMethod]
        public void Normal_info_cmd_parsed_ok()
        {
            var msg = parser.Deserialize(infoCmdNormalBytes);
            var infoCmd = msg as InfoCommand;
            Assert.AreEqual(0, infoCmd.Count);
        }

        [TestMethod]
        public void Info_command_with_double_FA_parsed_ok()
        {
            var msg = parser.Deserialize(infoCmdWithDoubleFA);
            var infoCmd = msg as InfoCommand;
            Assert.AreEqual(0, infoCmd.Count);
        }

        [TestMethod]
        public void Info_cmd_with_card_parsed_ok()
        {
            var msg = parser.Deserialize(infoCmdWithCardBytes);
            var infoCmd = msg as InfoCommand;
            Assert.AreEqual(1, infoCmd.Count);
            Assert.AreEqual(1, infoCmd.CardInsertedStates.Count);
            Assert.AreEqual("01020510100000000042", infoCmd.CardInsertedStates[0].ASN);
        }

        [TestMethod]
        public void Info_cmd_with_filling_status_parsed_ok()
        {
            var msg = parser.Deserialize(infoCmdWithFillingStatusBytes);
            var infoCmd = msg as InfoCommand;
            Assert.AreEqual(1, infoCmd.Count);
            Assert.AreEqual(537, infoCmd.NozzleOperatingStates[0].PRC);
        }

        [TestMethod]
        public void Transaction_data_is_parsed_ok()
        {
            var msg = parser.Deserialize(transactionDataBytes);
            var transactionDataCmd = msg as TransactionData;
            Assert.IsNotNull(transactionDataCmd);
            Assert.AreEqual(0x1BAD, transactionDataCmd.PosTtc);
            Assert.AreEqual("FFD5FF98", transactionDataCmd.Balance);
            Assert.AreEqual("20200807111456", transactionDataCmd.TransTime);
            Assert.AreEqual("01020510100000000042", transactionDataCmd.Asn);
            Assert.AreEqual(0x432, transactionDataCmd.Amount);
            Assert.AreEqual(2030, transactionDataCmd.GoodsCode);
            Assert.AreEqual(1, transactionDataCmd.NozzleNo);
            Assert.AreEqual(0xC8, transactionDataCmd.Volume);
            Assert.AreEqual(0x219, transactionDataCmd.Price);
            Assert.AreEqual(0x2DF, transactionDataCmd.Ctc);
            Assert.IsTrue(ValueEquals(new byte[2] { 0x74, 0xA7 }, transactionDataCmd.CRC));
        }

        [TestMethod]
        public void Trans_data_crc_ok()
        {
            var msg = parser.Deserialize(transData);
            var transDataCmd = msg as TransactionData;
            Assert.IsTrue(ValueEquals(new byte[2] { 0x21, 0x2D }, transDataCmd.CRC));
        }

        #region Helper method

        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;
        }

        public byte[] StringToByteArray(string hex)
        {
            int numberChars = hex.Length;
            byte[] bytes = new byte[numberChars / 2];
            for (int i = 0; i < numberChars; i += 2)
                bytes[i / 2] = Convert.ToByte(hex.Substring(i, 2), 16);
            return bytes;
        }

        public static string ByteArrayToString(byte[] ba)
        {
            return BitConverter.ToString(ba).Replace("-", "");
        }

        #endregion
    }
}