FCC/Test/Devices/ATGs/VeederRoot/Incoming_Message.cs

using Edge.Core.IndustryStandardInterface.ATG;
using Edge.Core.Parser.BinaryParser.Util;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using VeederRoot_ATG_Console.MessageEntity.Incoming;
using VeederRoot_ATG_Console.MessageEntity.Outgoing;
using static VeederRoot_ATG_Console.MessageEntity.Incoming.QueryInTankInventoryReportResponse.InventoryData;
using static VeederRoot_ATG_Console.MessageEntity.MessageBase;

namespace VeederRoot_Test
{
    [TestClass]
    public class Incoming_Message
    {
        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;
        }

        #region QueryInTankInventoryReportResponse

        [TestMethod]
        public void QueryInTankInventoryReportResponse_TestMethod1()
        {
            var raw = new byte[] { 
                //SOH
                0x01, 
                //Function Code (4 bytes) + TT (2 bytes)
                0x69, 0x32, 0x30, 0x31, 0x30, 0x30, 
                //Current Date and Time
                0x31, 0x38, 0x30, 0x35, 0x31, 0x30, 0x30, 0x36, 0x30, 0x33,
                //Tank Number (Decimal, 00=all)
                0x30, 0x31,
                //Product Code (one ASCII character [20h-7Eh])
                0x31,
                //Tank Status Bits
                0x30, 0x30, 0x30, 0x39,
                //Number of eight character Data Fields to follow (Hex), here value is 7
                0x30, 0x37,
                //1. Volume
                0x34, 0x34, 0x46, 0x41, 0x30, 0x30, 0x30, 0x30,
                //2. TC Volume
                0x34, 0x34, 0x46, 0x38, 0x41, 0x32, 0x45, 0x36,
                //3. Ullage
                0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
                //4. Height
                0x34, 0x34, 0x45, 0x34, 0x32, 0x46, 0x38, 0x37,
                //5. Water
                0x34, 0x32, 0x38, 0x30, 0x30, 0x30, 0x46, 0x30,
                //6. Temperature
                0x34, 0x31, 0x42, 0x41, 0x43, 0x38, 0x43, 0x37,
                //7. Water Volume
                0x34, 0x32, 0x32, 0x30, 0x43, 0x30, 0x35, 0x39,
                //&& - Data Termination Flag
                0x26, 0x26, 
                //CCCC - Message Checksum
                0x45, 0x45, 0x41, 0x39, 
                //ETX
                0x03 };

            var request = new QueryInTankInventoryReportResponse();
            var p = new VeederRoot_ATG_Console.Parser();
            var actual = p.Deserialize(raw.ToArray()) as QueryInTankInventoryReportResponse;
            Assert.AreEqual(true, actual != null);
            Assert.AreEqual(true, actual.TankNumberInFunctionCode == 0);
            Assert.AreEqual(true, actual.InventoryDatas != null);
            Assert.AreEqual(true, actual.InventoryDatas.Count == 1);
            foreach (var oneTankData in actual.InventoryDatas)
            {
                Assert.AreEqual(true, oneTankData.TankNumber == 1);
                Assert.AreEqual(true, oneTankData.ProductCode == '1');
                Assert.AreEqual(true, oneTankData.States != null);
                Assert.AreEqual(true, oneTankData.States.Count == 1);
                Assert.AreEqual(true, oneTankData.States.First()
                        == QueryInTankInventoryReportResponse.InventoryData.TankState.DeliveryInProgress_LSB);
                Assert.AreEqual(true, oneTankData.NumberOfEightCharDataFieldsToFollow == 7);
                Assert.AreEqual(true, oneTankData.TankReadingDatas != null);
                Assert.AreEqual(true, oneTankData.TankReadingDatas.Count == 7);

                Assert.AreEqual(true,
                    oneTankData.TankReadingDatas.TryGetValue(
                        TankReadingDataName.Volume,
                        out double volumeRead));
                Assert.AreEqual(true, volumeRead == VeederRoot_ATG_Console.Util.ConvertIEEEWith4BytesToDouble(new byte[] { 0x44, 0xFA, 0x00, 0x00 }));

                Assert.AreEqual(true,
                    oneTankData.TankReadingDatas.TryGetValue(
                        TankReadingDataName.TC_Volume,
                        out double tcVolumeRead));
                Assert.AreEqual(true, tcVolumeRead == VeederRoot_ATG_Console.Util.ConvertIEEEWith4BytesToDouble(new byte[] { 0x44, 0xF8, 0xA2, 0xE6 }));

                Assert.AreEqual(true,
                    oneTankData.TankReadingDatas.TryGetValue(
                        TankReadingDataName.WaterVolume,
                        out double waterVolumeRead));
                Assert.AreEqual(true, waterVolumeRead == VeederRoot_ATG_Console.Util.ConvertIEEEWith4BytesToDouble(new byte[] { 0x42, 0x20, 0xC0, 0x59 }));

                foreach (var oneReading in oneTankData.TankReadingDatas)
                {
                }
            }
        }

        [TestMethod]
        public void QueryInTankInventoryReportResponse_TestMethod2()
        {
            var raw = new byte[] { 
                //SOH
                0x01, 
                //Function Code (4 bytes) + TT (2 bytes)
                0x69, 0x32, 0x30, 0x31, 0x30, 0x30, 
                //Current Date and Time
                0x31, 0x38, 0x30, 0x35, 0x31, 0x30, 0x30, 0x36, 0x30, 0x33,
                //Tank Number (Decimal, 00=all)
                0x30, 0x31,
                //Product Code (one ASCII character [20h-7Eh])
                0x31,
                //Tank Status Bits
                0x30, 0x30, 0x30, 0x34,
                //Number of eight character Data Fields to follow (Hex), here value is 7
                0x30, 0x37,
                //1. Volume
                0x34, 0x34, 0x46, 0x41, 0x30, 0x30, 0x30, 0x30,
                //2. TC Volume
                0x34, 0x34, 0x46, 0x38, 0x41, 0x32, 0x45, 0x36,
                //3. Ullage
                0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
                //4. Height
                0x34, 0x34, 0x45, 0x34, 0x32, 0x46, 0x38, 0x37,
                //5. Water
                0x34, 0x32, 0x38, 0x30, 0x30, 0x30, 0x46, 0x30,
                //6. Temperature
                0x34, 0x31, 0x42, 0x41, 0x43, 0x38, 0x43, 0x37,
                //7. Water Volume
                0x34, 0x32, 0x32, 0x30, 0x43, 0x30, 0x35, 0x39,

                //Tank Number (Decimal, 00=all)
                0x30, 0x32,
                //Product Code (one ASCII character [20h-7Eh])
                0x32,
                //Tank Status Bits
                0x30, 0x30, 0x30, 0x34,
                //Number of eight character Data Fields to follow (Hex), here value is 7
                0x30, 0x37,
                //1. Volume
                0x34, 0x34, 0x46, 0x41, 0x30, 0x30, 0x30, 0x30,
                //2. TC Volume
                0x34, 0x34, 0x46, 0x38, 0x41, 0x32, 0x45, 0x36,
                //3. Ullage
                0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
                //4. Height
                0x34, 0x34, 0x45, 0x34, 0x32, 0x46, 0x38, 0x37,
                //5. Water
                0x34, 0x32, 0x38, 0x30, 0x30, 0x30, 0x46, 0x30,
                //6. Temperature
                0x34, 0x31, 0x42, 0x41, 0x43, 0x38, 0x43, 0x37,
                //7. Water Volume
                0x34, 0x32, 0x32, 0x30, 0x43, 0x30, 0x35, 0x39,
                //&& - Data Termination Flag
                0x26, 0x26, 
                //CCCC - Message Checksum
                0x45, 0x45, 0x41, 0x39, 
                //ETX
                0x03 };

            var request = new QueryInTankInventoryReportResponse();
            var p = new VeederRoot_ATG_Console.Parser();
            var actual = p.Deserialize(raw.ToArray()) as QueryInTankInventoryReportResponse;
            Assert.AreEqual(true, actual != null);
            Assert.AreEqual(true, actual.TankNumberInFunctionCode == 0);
            Assert.AreEqual(true, actual.InventoryDatas != null);
            Assert.AreEqual(true, actual.InventoryDatas.Count == 2);
            for (int i = 0; i < actual.InventoryDatas.Count; i++)
            {
                var oneTankData = actual.InventoryDatas[i];
                Assert.AreEqual(true, oneTankData.TankNumber == i + 1);
                Assert.AreEqual(true, oneTankData.ProductCode == char.Parse((i + 1).ToString()));
                Assert.AreEqual(true, oneTankData.States != null);
                Assert.AreEqual(true, oneTankData.States.Count == 1);
                Assert.AreEqual(true, oneTankData.States.First()
                        == QueryInTankInventoryReportResponse.InventoryData.TankState.InvalidFuelHeighAlarm_MagProbesOnly);
                Assert.AreEqual(true, oneTankData.NumberOfEightCharDataFieldsToFollow == 7);
                Assert.AreEqual(true, oneTankData.TankReadingDatas != null);
                Assert.AreEqual(true, oneTankData.TankReadingDatas.Count == 7);

                Assert.AreEqual(true,
                    oneTankData.TankReadingDatas.TryGetValue(
                        TankReadingDataName.Volume,
                        out double volumeRead));
                Assert.AreEqual(true, volumeRead == VeederRoot_ATG_Console.Util.ConvertIEEEWith4BytesToDouble(new byte[] { 0x44, 0xFA, 0x00, 0x00 }));

                Assert.AreEqual(true,
                    oneTankData.TankReadingDatas.TryGetValue(
                        TankReadingDataName.TC_Volume,
                        out double tcVolumeRead));
                Assert.AreEqual(true, tcVolumeRead == VeederRoot_ATG_Console.Util.ConvertIEEEWith4BytesToDouble(new byte[] { 0x44, 0xF8, 0xA2, 0xE6 }));

                Assert.AreEqual(true,
                    oneTankData.TankReadingDatas.TryGetValue(
                        TankReadingDataName.WaterVolume,
                        out double waterVolumeRead));
                Assert.AreEqual(true, waterVolumeRead == VeederRoot_ATG_Console.Util.ConvertIEEEWith4BytesToDouble(new byte[] { 0x42, 0x20, 0xC0, 0x59 }));

                foreach (var oneReading in oneTankData.TankReadingDatas)
                {
                }
            }
        }

        [TestMethod]
        public void QueryInTankInventoryReportResponse_TestMethod3()
        {
            var raw = new byte[] { 
                //SOH
                0x01, 
                //Function Code (4 bytes) + TT (2 bytes)
                0x69, 0x32, 0x30, 0x31, 0x30, 0x30, 
                //Current Date and Time
                0x31, 0x38, 0x30, 0x35, 0x31, 0x30, 0x30, 0x36, 0x30, 0x33,
                //Tank Number (Decimal, 00=all)
                0x30, 0x31,
                //Product Code (one ASCII character [20h-7Eh])
                0x31,
                //Tank Status Bits
                0x30, 0x30, 0x30, 0x34,
                //Number of eight character Data Fields to follow (Hex), here value is 7
                0x30, 0x37,
                //1. Volume
                0x34, 0x34, 0x46, 0x41, 0x30, 0x30, 0x30, 0x30,
                //2. TC Volume
                0x34, 0x34, 0x46, 0x38, 0x41, 0x32, 0x45, 0x36,
                //3. Ullage
                0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
                //4. Height
                0x34, 0x34, 0x45, 0x34, 0x32, 0x46, 0x38, 0x37,
                //5. Water
                0x34, 0x32, 0x38, 0x30, 0x30, 0x30, 0x46, 0x30,
                //6. Temperature
                0x34, 0x31, 0x42, 0x41, 0x43, 0x38, 0x43, 0x37,
                //7. Water Volume
                0x34, 0x32, 0x32, 0x30, 0x43, 0x30, 0x35, 0x39,

                //Tank Number (Decimal, 00=all)
                0x30, 0x32,
                //Product Code (one ASCII character [20h-7Eh])
                0x32,
                //Tank Status Bits
                0x30, 0x30, 0x30, 0x34,
                //Number of eight character Data Fields to follow (Hex), here value is 7
                0x30, 0x37,
                //1. Volume
                0x34, 0x34, 0x46, 0x41, 0x30, 0x30, 0x30, 0x30,
                //2. TC Volume
                0x34, 0x34, 0x46, 0x38, 0x41, 0x32, 0x45, 0x36,
                //3. Ullage
                0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
                //4. Height
                0x34, 0x34, 0x45, 0x34, 0x32, 0x46, 0x38, 0x37,
                //5. Water
                0x34, 0x32, 0x38, 0x30, 0x30, 0x30, 0x46, 0x30,
                //6. Temperature
                0x34, 0x31, 0x42, 0x41, 0x43, 0x38, 0x43, 0x37,
                //7. Water Volume
                0x34, 0x32, 0x32, 0x30, 0x43, 0x30, 0x35, 0x39,

                //Tank Number (Decimal, 00=all)
                0x30, 0x33,
                //Product Code (one ASCII character [20h-7Eh])
                0x33,
                //Tank Status Bits
                0x30, 0x30, 0x30, 0x34,
                //Number of eight character Data Fields to follow (Hex), here value is 7
                0x30, 0x37,
                //1. Volume
                0x34, 0x34, 0x46, 0x41, 0x30, 0x30, 0x30, 0x30,
                //2. TC Volume
                0x34, 0x34, 0x46, 0x38, 0x41, 0x32, 0x45, 0x36,
                //3. Ullage
                0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
                //4. Height
                0x34, 0x34, 0x45, 0x34, 0x32, 0x46, 0x38, 0x37,
                //5. Water
                0x34, 0x32, 0x38, 0x30, 0x30, 0x30, 0x46, 0x30,
                //6. Temperature
                0x34, 0x31, 0x42, 0x41, 0x43, 0x38, 0x43, 0x37,
                //7. Water Volume
                0x34, 0x32, 0x32, 0x30, 0x43, 0x30, 0x35, 0x39,

                //Tank Number (Decimal, 00=all)
                0x30, 0x34,
                //Product Code (one ASCII character [20h-7Eh])
                0x34,
                //Tank Status Bits
                0x30, 0x30, 0x30, 0x34,
                //Number of eight character Data Fields to follow (Hex), here value is 7
                0x30, 0x37,
                //1. Volume
                0x34, 0x34, 0x46, 0x41, 0x30, 0x30, 0x30, 0x30,
                //2. TC Volume
                0x34, 0x34, 0x46, 0x38, 0x41, 0x32, 0x45, 0x36,
                //3. Ullage
                0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
                //4. Height
                0x34, 0x34, 0x45, 0x34, 0x32, 0x46, 0x38, 0x37,
                //5. Water
                0x34, 0x32, 0x38, 0x30, 0x30, 0x30, 0x46, 0x30,
                //6. Temperature
                0x34, 0x31, 0x42, 0x41, 0x43, 0x38, 0x43, 0x37,
                //7. Water Volume
                0x34, 0x32, 0x32, 0x30, 0x43, 0x30, 0x35, 0x39,

                //Tank Number (Decimal, 00=all)
                0x30, 0x35,
                //Product Code (one ASCII character [20h-7Eh])
                0x35,
                //Tank Status Bits
                0x30, 0x30, 0x30, 0x34,
                //Number of eight character Data Fields to follow (Hex), here value is 7
                0x30, 0x37,
                //1. Volume
                0x34, 0x34, 0x46, 0x41, 0x30, 0x30, 0x30, 0x30,
                //2. TC Volume
                0x34, 0x34, 0x46, 0x38, 0x41, 0x32, 0x45, 0x36,
                //3. Ullage
                0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
                //4. Height
                0x34, 0x34, 0x45, 0x34, 0x32, 0x46, 0x38, 0x37,
                //5. Water
                0x34, 0x32, 0x38, 0x30, 0x30, 0x30, 0x46, 0x30,
                //6. Temperature
                0x34, 0x31, 0x42, 0x41, 0x43, 0x38, 0x43, 0x37,
                //7. Water Volume
                0x34, 0x32, 0x32, 0x30, 0x43, 0x30, 0x35, 0x39,

                //Tank Number (Decimal, 00=all)
                0x30, 0x36,
                //Product Code (one ASCII character [20h-7Eh])
                0x36,
                //Tank Status Bits
                0x30, 0x30, 0x30, 0x34,
                //Number of eight character Data Fields to follow (Hex), here value is 7
                0x30, 0x37,
                //1. Volume
                0x34, 0x34, 0x46, 0x41, 0x30, 0x30, 0x30, 0x30,
                //2. TC Volume
                0x34, 0x34, 0x46, 0x38, 0x41, 0x32, 0x45, 0x36,
                //3. Ullage
                0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
                //4. Height
                0x34, 0x34, 0x45, 0x34, 0x32, 0x46, 0x38, 0x37,
                //5. Water
                0x34, 0x32, 0x38, 0x30, 0x30, 0x30, 0x46, 0x30,
                //6. Temperature
                0x34, 0x31, 0x42, 0x41, 0x43, 0x38, 0x43, 0x37,
                //7. Water Volume
                0x34, 0x32, 0x32, 0x30, 0x43, 0x30, 0x35, 0x39,

                //Tank Number (Decimal, 00=all)
                0x30, 0x37,
                //Product Code (one ASCII character [20h-7Eh])
                0x37,
                //Tank Status Bits
                0x30, 0x30, 0x30, 0x34,
                //Number of eight character Data Fields to follow (Hex), here value is 7
                0x30, 0x37,
                //1. Volume
                0x34, 0x34, 0x46, 0x41, 0x30, 0x30, 0x30, 0x30,
                //2. TC Volume
                0x34, 0x34, 0x46, 0x38, 0x41, 0x32, 0x45, 0x36,
                //3. Ullage
                0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
                //4. Height
                0x34, 0x34, 0x45, 0x34, 0x32, 0x46, 0x38, 0x37,
                //5. Water
                0x34, 0x32, 0x38, 0x30, 0x30, 0x30, 0x46, 0x30,
                //6. Temperature
                0x34, 0x31, 0x42, 0x41, 0x43, 0x38, 0x43, 0x37,
                //7. Water Volume
                0x34, 0x32, 0x32, 0x30, 0x43, 0x30, 0x35, 0x39,

                //Tank Number (Decimal, 00=all)
                0x30, 0x38,
                //Product Code (one ASCII character [20h-7Eh])
                0x38,
                //Tank Status Bits
                0x30, 0x30, 0x30, 0x34,
                //Number of eight character Data Fields to follow (Hex), here value is 7
                0x30, 0x37,
                //1. Volume
                0x34, 0x34, 0x46, 0x41, 0x30, 0x30, 0x30, 0x30,
                //2. TC Volume
                0x34, 0x34, 0x46, 0x38, 0x41, 0x32, 0x45, 0x36,
                //3. Ullage
                0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
                //4. Height
                0x34, 0x34, 0x45, 0x34, 0x32, 0x46, 0x38, 0x37,
                //5. Water
                0x34, 0x32, 0x38, 0x30, 0x30, 0x30, 0x46, 0x30,
                //6. Temperature
                0x34, 0x31, 0x42, 0x41, 0x43, 0x38, 0x43, 0x37,
                //7. Water Volume
                0x34, 0x32, 0x32, 0x30, 0x43, 0x30, 0x35, 0x39,

                //&& - Data Termination Flag
                0x26, 0x26, 
                //CCCC - Message Checksum
                0x45, 0x45, 0x41, 0x39, 
                //ETX
                0x03 };

            var request = new QueryInTankInventoryReportResponse();
            var p = new VeederRoot_ATG_Console.Parser();
            var actual = p.Deserialize(raw.ToArray()) as QueryInTankInventoryReportResponse;
            Assert.AreEqual(true, actual != null);
            Assert.AreEqual(true, actual.TankNumberInFunctionCode == 0);
            Assert.AreEqual(true, actual.InventoryDatas != null);
            Assert.AreEqual(true, actual.InventoryDatas.Count == 8);
            for (int i = 0; i < actual.InventoryDatas.Count; i++)
            {
                var oneTankData = actual.InventoryDatas[i];
                Assert.AreEqual(true, oneTankData.TankNumber == i + 1);
                Assert.AreEqual(true, oneTankData.ProductCode == char.Parse((i + 1).ToString()));
                Assert.AreEqual(true, oneTankData.States != null);
                Assert.AreEqual(true, oneTankData.States.Count == 1);
                Assert.AreEqual(true, oneTankData.States.First()
                        == QueryInTankInventoryReportResponse.InventoryData.TankState.InvalidFuelHeighAlarm_MagProbesOnly);
                Assert.AreEqual(true, oneTankData.NumberOfEightCharDataFieldsToFollow == 7);
                Assert.AreEqual(true, oneTankData.TankReadingDatas != null);
                Assert.AreEqual(true, oneTankData.TankReadingDatas.Count == 7);

                Assert.AreEqual(true,
                    oneTankData.TankReadingDatas.TryGetValue(
                        TankReadingDataName.Volume,
                        out double volumeRead));
                Assert.AreEqual(true, volumeRead == VeederRoot_ATG_Console.Util.ConvertIEEEWith4BytesToDouble(new byte[] { 0x44, 0xFA, 0x00, 0x00 }));

                Assert.AreEqual(true,
                    oneTankData.TankReadingDatas.TryGetValue(
                        TankReadingDataName.TC_Volume,
                        out double tcVolumeRead));
                Assert.AreEqual(true, tcVolumeRead == VeederRoot_ATG_Console.Util.ConvertIEEEWith4BytesToDouble(new byte[] { 0x44, 0xF8, 0xA2, 0xE6 }));

                Assert.AreEqual(true,
                    oneTankData.TankReadingDatas.TryGetValue(
                        TankReadingDataName.WaterVolume,
                        out double waterVolumeRead));
                Assert.AreEqual(true, waterVolumeRead == VeederRoot_ATG_Console.Util.ConvertIEEEWith4BytesToDouble(new byte[] { 0x42, 0x20, 0xC0, 0x59 }));

                foreach (var oneReading in oneTankData.TankReadingDatas)
                {
                }
            }
        }

        #endregion
        [TestMethod]
        public void QueryInTankMostRecentDeliveryReportResponse_TestMethod0()
        {
            var raw = "01 69 32 30 43 31 32 32 31 30 34 31 35 31 34 34 39 31 32 36 30 31 32 30 31 32 31 31 31 39 35 34 32 30 31 32 31 31 32 30 34 39 31 30 34 36 43 45 34 46 46 42 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 34 31 42 36 41 37 35 39 34 37 33 42 42 39 38 41 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 34 31 42 41 37 46 45 30 34 34 42 33 39 39 39 31 34 35 31 42 44 34 30 38 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 26 26 44 44 31 45 03".ToBytes();
            var p = new VeederRoot_ATG_Console.Parser();
            var actual = p.Deserialize(raw.ToArray()) as QueryInTankMostRecentDeliveryReportResponse;
            Assert.AreEqual(true, actual != null);
            Assert.AreEqual(true, actual.TankNumberInFunctionCode == 12);
            Assert.AreEqual(true, actual.DeliveriesForTanks != null);
            Assert.AreEqual(true, actual.DeliveriesForTanks.Count == 1);
            Assert.AreEqual(true, actual.DeliveriesForTanks.First().TankNumber == 12);
        }

        [TestMethod]
        public void QueryInTankMostRecentDeliveryReportResponse_TestMethod1()
        {
            var raw = new byte[] { 
                //SOH
                0x01, 
                //Function Code (4 bytes) + TT (2 bytes)
                0x69, 0x32, 0x30, 0x43, 0x30, 0x30, 
                //Current Date and Time
                0x31, 0x38, 0x30, 0x35, 0x31, 0x30, 0x30, 0x36, 0x30, 0x33,
                //Tank Number (Decimal, 00=all)
                0x30, 0x31,
                //Product Code (one ASCII character [20h-7Eh])
                0x31,
                //Number of Deliveries to follow (Decimal, 00 if no data available for this tank)
                0x30,0x31,
                //Starting Date/Time
                0x32,0x30,0x30,0x31,0x30,0x36,0x31,0x34,0x31,0x39,
                //Ending Date/Time
                0x32,0x30,0x30,0x31,0x30,0x36,0x31,0x34,0x32,0x31,
                //Number of eight character Data Fields to follow (Hex)
                0x31,0x30,
                0x34,0x34,0x44,0x44,0x39,0x37,0x44,0x45,
                0x34,0x34,0x44,0x43,0x32,0x45,0x44,0x42,
                0x34,0x33,0x44,0x42,0x38,0x39,0x42,0x45,
                0x34,0x31,0x43,0x35,0x32,0x43,0x42,0x41,
                0x34,0x34,0x46,0x41,0x30,0x30,0x30,0x30,
                0x34,0x34,0x46,0x38,0x36,0x38,0x41,0x45,
                0x34,0x33,0x46,0x45,0x41,0x43,0x37,0x46,
                0x34,0x31,0x43,0x35,0x32,0x45,0x32,0x35,
                0x34,0x34,0x37,0x43,0x42,0x32,0x38,0x46,
                0x34,0x34,0x42,0x38,0x38,0x36,0x46,0x41,
                0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,
                0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,
                0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,
                0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,
                0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,
                0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,
                //&& - Data Termination Flag
                0x26, 0x26, 
                //CCCC - Message Checksum
                0x45, 0x45, 0x41, 0x39, 
                //ETX
                0x03 };

            var response = new QueryInTankMostRecentDeliveryReportResponse();
            var p = new VeederRoot_ATG_Console.Parser();
            var actual = p.Deserialize(raw.ToArray()) as QueryInTankMostRecentDeliveryReportResponse;
            Assert.AreEqual(true, actual != null);
            Assert.AreEqual(true, actual.TankNumberInFunctionCode == 0);
            Assert.AreEqual(true, actual.DeliveriesForTanks != null);
            Assert.AreEqual(true, actual.DeliveriesForTanks.Count == 1);
            foreach (var deliveriesForOneTank in actual.DeliveriesForTanks)
            {
                Assert.AreEqual(true, deliveriesForOneTank.TankNumber == 1);
                Assert.AreEqual(true, deliveriesForOneTank.ProductCode == '1');
                Assert.AreEqual(true, deliveriesForOneTank.Deliveries != null);
                Assert.AreEqual(true, deliveriesForOneTank.Deliveries.Count == 1);

                foreach (var delivery in deliveriesForOneTank.Deliveries)
                {
                    //foreach (var deliveryReadingDataName in delivery.Datas.Keys)
                    //{
                    //    var _ = delivery.Datas[deliveryReadingDataName];
                    //}
                    Assert.AreEqual(true,
                        delivery.Datas.TryGetValue(
                            Edge.Core.IndustryStandardInterface.ATG.DeliveryReadingDataName.StartingVolume,
                            out double startingVolumeRead));
                    Assert.AreEqual(true, startingVolumeRead
                        == VeederRoot_ATG_Console.Util.ConvertIEEEWith4BytesToDouble(
                            new byte[] { 
                                //0x34,0x34,0x44,0x44,0x39,0x37,0x44,0x45,
                                0x44, 0xDD, 0x97, 0xDE }));

                    Assert.AreEqual(true,
                        delivery.Datas.TryGetValue(
                            Edge.Core.IndustryStandardInterface.ATG.DeliveryReadingDataName.StartingTcVolume,
                            out double startingTcVolumeRead));
                    Assert.AreEqual(true, startingTcVolumeRead
                        == VeederRoot_ATG_Console.Util.ConvertIEEEWith4BytesToDouble(
                            new byte[] { 
                                //0x34,0x34,0x44,0x43,0x32,0x45,0x44,0x42,
                                0x44, 0xDC, 0x2E, 0xDB }));

                    Assert.AreEqual(true,
                        delivery.Datas.TryGetValue(
                            Edge.Core.IndustryStandardInterface.ATG.DeliveryReadingDataName.StartingHeight,
                            out double startingHeightRead));
                    Assert.AreEqual(true, startingHeightRead
                        == VeederRoot_ATG_Console.Util.ConvertIEEEWith4BytesToDouble(
                            new byte[] { 
                                //0x34,0x34,0x37,0x43,0x42,0x32,0x38,0x46,
                                0x44, 0x7C, 0xB2, 0x8F }));

                    Assert.AreEqual(true,
                        delivery.Datas.TryGetValue(
                            Edge.Core.IndustryStandardInterface.ATG.DeliveryReadingDataName.EndingHeight,
                            out double endingHeightRead));
                    Assert.AreEqual(true, endingHeightRead
                        == VeederRoot_ATG_Console.Util.ConvertIEEEWith4BytesToDouble(
                            new byte[] { 
                                //0x34,0x34,0x42,0x38,0x38,0x36,0x46,0x41,
                                0x44, 0xB8, 0x86, 0xFA }));

                }
            }
        }

        [TestMethod]
        public void QueryInTankMostRecentDeliveryReportResponse_TestMethod2()
        {
            var raw = new byte[] { 
                //SOH
                0x01, 
                //Function Code (4 bytes) + TT (2 bytes)
                0x69, 0x32, 0x30, 0x43, 0x30, 0x30, 
                //Current Date and Time
                0x31, 0x38, 0x30, 0x35, 0x31, 0x30, 0x30, 0x36, 0x30, 0x33,

                //================================================
                //Tank Number (Decimal, 00=all)
                0x30, 0x31,
                //Product Code (one ASCII character [20h-7Eh])
                0x31,
                //Number of Deliveries to follow (Decimal, 00 if no data available for this tank)
                0x30,0x31,
                //Starting Date/Time
                0x32,0x30,0x30,0x31,0x30,0x36,0x31,0x34,0x31,0x39,
                //Ending Date/Time
                0x32,0x30,0x30,0x31,0x30,0x36,0x31,0x34,0x32,0x31,
                //Number of eight character Data Fields to follow (Hex)
                0x31,0x30,
                0x34,0x34,0x44,0x44,0x39,0x37,0x44,0x45,
                0x34,0x34,0x44,0x43,0x32,0x45,0x44,0x42,
                0x34,0x33,0x44,0x42,0x38,0x39,0x42,0x45,
                0x34,0x31,0x43,0x35,0x32,0x43,0x42,0x41,
                0x34,0x34,0x46,0x41,0x30,0x30,0x30,0x30,
                0x34,0x34,0x46,0x38,0x36,0x38,0x41,0x45,
                0x34,0x33,0x46,0x45,0x41,0x43,0x37,0x46,
                0x34,0x31,0x43,0x35,0x32,0x45,0x32,0x35,
                0x34,0x34,0x37,0x43,0x42,0x32,0x38,0x46,
                0x34,0x34,0x42,0x38,0x38,0x36,0x46,0x41,
                0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,
                0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,
                0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,
                0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,
                0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,
                0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,


                //================================================
                //Tank Number (Decimal, 00=all)
                0x30, 0x32,
                //Product Code (one ASCII character [20h-7Eh])
                0x32,
                //Number of Deliveries to follow (Decimal, 00 if no data available for this tank)
                0x30,0x31,
                //Starting Date/Time
                0x32,0x30,0x30,0x31,0x30,0x36,0x31,0x34,0x31,0x39,
                //Ending Date/Time
                0x32,0x30,0x30,0x31,0x30,0x36,0x31,0x34,0x32,0x31,
                //Number of eight character Data Fields to follow (Hex)
                0x31,0x30,
                0x34,0x34,0x44,0x44,0x39,0x37,0x44,0x45,
                0x34,0x34,0x44,0x43,0x32,0x45,0x44,0x42,
                0x34,0x33,0x44,0x42,0x38,0x39,0x42,0x45,
                0x34,0x31,0x43,0x35,0x32,0x43,0x42,0x41,
                0x34,0x34,0x46,0x41,0x30,0x30,0x30,0x30,
                0x34,0x34,0x46,0x38,0x36,0x38,0x41,0x45,
                0x34,0x33,0x46,0x45,0x41,0x43,0x37,0x46,
                0x34,0x31,0x43,0x35,0x32,0x45,0x32,0x35,
                0x34,0x34,0x37,0x43,0x42,0x32,0x38,0x46,
                0x34,0x34,0x42,0x38,0x38,0x36,0x46,0x41,
                0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,
                0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,
                0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,
                0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,
                0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,
                0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,



                //================================================
                //Tank Number (Decimal, 00=all)
                0x30, 0x33,
                //Product Code (one ASCII character [20h-7Eh])
                0x33,
                //Number of Deliveries to follow (Decimal, 00 if no data available for this tank)
                0x30,0x31,
                //Starting Date/Time
                0x32,0x30,0x30,0x31,0x30,0x36,0x31,0x34,0x31,0x39,
                //Ending Date/Time
                0x32,0x30,0x30,0x31,0x30,0x36,0x31,0x34,0x32,0x31,
                //Number of eight character Data Fields to follow (Hex)
                0x31,0x30,
                0x34,0x34,0x44,0x44,0x39,0x37,0x44,0x45,
                0x34,0x34,0x44,0x43,0x32,0x45,0x44,0x42,
                0x34,0x33,0x44,0x42,0x38,0x39,0x42,0x45,
                0x34,0x31,0x43,0x35,0x32,0x43,0x42,0x41,
                0x34,0x34,0x46,0x41,0x30,0x30,0x30,0x30,
                0x34,0x34,0x46,0x38,0x36,0x38,0x41,0x45,
                0x34,0x33,0x46,0x45,0x41,0x43,0x37,0x46,
                0x34,0x31,0x43,0x35,0x32,0x45,0x32,0x35,
                0x34,0x34,0x37,0x43,0x42,0x32,0x38,0x46,
                0x34,0x34,0x42,0x38,0x38,0x36,0x46,0x41,
                0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,
                0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,
                0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,
                0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,
                0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,
                0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,


                //================================================
                //Tank Number (Decimal, 00=all)
                0x30, 0x34,
                //Product Code (one ASCII character [20h-7Eh])
                0x34,
                //Number of Deliveries to follow (Decimal, 00 if no data available for this tank)
                0x30,0x31,
                //Starting Date/Time
                0x32,0x30,0x30,0x31,0x30,0x36,0x31,0x34,0x31,0x39,
                //Ending Date/Time
                0x32,0x30,0x30,0x31,0x30,0x36,0x31,0x34,0x32,0x31,
                //Number of eight character Data Fields to follow (Hex)
                0x31,0x30,
                0x34,0x34,0x44,0x44,0x39,0x37,0x44,0x45,
                0x34,0x34,0x44,0x43,0x32,0x45,0x44,0x42,
                0x34,0x33,0x44,0x42,0x38,0x39,0x42,0x45,
                0x34,0x31,0x43,0x35,0x32,0x43,0x42,0x41,
                0x34,0x34,0x46,0x41,0x30,0x30,0x30,0x30,
                0x34,0x34,0x46,0x38,0x36,0x38,0x41,0x45,
                0x34,0x33,0x46,0x45,0x41,0x43,0x37,0x46,
                0x34,0x31,0x43,0x35,0x32,0x45,0x32,0x35,
                0x34,0x34,0x37,0x43,0x42,0x32,0x38,0x46,
                0x34,0x34,0x42,0x38,0x38,0x36,0x46,0x41,
                0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,
                0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,
                0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,
                0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,
                0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,
                0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,



                //&& - Data Termination Flag
                0x26, 0x26, 
                //CCCC - Message Checksum
                0x45, 0x45, 0x41, 0x39, 
                //ETX
                0x03 };

            var response = new QueryInTankMostRecentDeliveryReportResponse();
            var p = new VeederRoot_ATG_Console.Parser();
            var actual = p.Deserialize(raw.ToArray()) as QueryInTankMostRecentDeliveryReportResponse;
            Assert.AreEqual(true, actual != null);
            Assert.AreEqual(true, actual.TankNumberInFunctionCode == 0);
            Assert.AreEqual(true, actual.DeliveriesForTanks != null);
            Assert.AreEqual(true, actual.DeliveriesForTanks.Count == 4);
            for (int i = 0; i < actual.DeliveriesForTanks.Count; i++)
            {
                var deliveriesForOneTank = actual.DeliveriesForTanks[i];
                Assert.AreEqual(true, deliveriesForOneTank.TankNumber == i + 1);
                Assert.AreEqual(true, deliveriesForOneTank.ProductCode == char.Parse((i + 1).ToString()));
                Assert.AreEqual(true, deliveriesForOneTank.Deliveries != null);
                Assert.AreEqual(true, deliveriesForOneTank.Deliveries.Count == 1);

                foreach (var delivery in deliveriesForOneTank.Deliveries)
                {
                    //foreach (var deliveryReadingDataName in delivery.Datas.Keys)
                    //{
                    //    var _ = delivery.Datas[deliveryReadingDataName];
                    //}
                    Assert.AreEqual(true,
                        delivery.Datas.TryGetValue(
                            Edge.Core.IndustryStandardInterface.ATG.DeliveryReadingDataName.StartingVolume,
                            out double startingVolumeRead));
                    Assert.AreEqual(true, startingVolumeRead
                        == VeederRoot_ATG_Console.Util.ConvertIEEEWith4BytesToDouble(
                            new byte[] { 
                                //0x34,0x34,0x44,0x44,0x39,0x37,0x44,0x45,
                                0x44, 0xDD, 0x97, 0xDE }));

                    Assert.AreEqual(true,
                        delivery.Datas.TryGetValue(
                            Edge.Core.IndustryStandardInterface.ATG.DeliveryReadingDataName.StartingTcVolume,
                            out double startingTcVolumeRead));
                    Assert.AreEqual(true, startingTcVolumeRead
                        == VeederRoot_ATG_Console.Util.ConvertIEEEWith4BytesToDouble(
                            new byte[] { 
                                //0x34,0x34,0x44,0x43,0x32,0x45,0x44,0x42,
                                0x44, 0xDC, 0x2E, 0xDB }));

                    Assert.AreEqual(true,
                        delivery.Datas.TryGetValue(
                            Edge.Core.IndustryStandardInterface.ATG.DeliveryReadingDataName.StartingHeight,
                            out double startingHeightRead));
                    Assert.AreEqual(true, startingHeightRead
                        == VeederRoot_ATG_Console.Util.ConvertIEEEWith4BytesToDouble(
                            new byte[] { 
                                //0x34,0x34,0x37,0x43,0x42,0x32,0x38,0x46,
                                0x44, 0x7C, 0xB2, 0x8F }));

                    Assert.AreEqual(true,
                        delivery.Datas.TryGetValue(
                            Edge.Core.IndustryStandardInterface.ATG.DeliveryReadingDataName.EndingHeight,
                            out double endingHeightRead));
                    Assert.AreEqual(true, endingHeightRead
                        == VeederRoot_ATG_Console.Util.ConvertIEEEWith4BytesToDouble(
                            new byte[] { 
                                //0x34,0x34,0x42,0x38,0x38,0x36,0x46,0x41,
                                0x44, 0xB8, 0x86, 0xFA }));

                }
            }
        }

        [TestMethod]
        public void QueryInTankMostRecentDeliveryReportResponse_TestMethod3()
        {
            var raw = new byte[] { 
                //SOH
                0x01, 
                //Function Code (4 bytes) + TT (2 bytes)
                0x69, 0x32, 0x30, 0x43, 0x30, 0x30, 
                //Current Date and Time
                0x31, 0x38, 0x30, 0x35, 0x31, 0x30, 0x30, 0x36, 0x30, 0x33,

                //================================================
                //Tank Number (Decimal, 00=all)
                0x30, 0x31,
                //Product Code (one ASCII character [20h-7Eh])
                0x31,
                //Number of Deliveries to follow (Decimal, 00 if no data available for this tank)
                0x30,0x32,
                //Starting Date/Time
                0x32,0x30,0x30,0x31,0x30,0x36,0x31,0x34,0x31,0x39,
                //Ending Date/Time
                0x32,0x30,0x30,0x31,0x30,0x36,0x31,0x34,0x32,0x31,
                //Number of eight character Data Fields to follow (Hex)
                0x31,0x30,
                0x34,0x34,0x44,0x44,0x39,0x37,0x44,0x45,
                0x34,0x34,0x44,0x43,0x32,0x45,0x44,0x42,
                0x34,0x33,0x44,0x42,0x38,0x39,0x42,0x45,
                0x34,0x31,0x43,0x35,0x32,0x43,0x42,0x41,
                0x34,0x34,0x46,0x41,0x30,0x30,0x30,0x30,
                0x34,0x34,0x46,0x38,0x36,0x38,0x41,0x45,
                0x34,0x33,0x46,0x45,0x41,0x43,0x37,0x46,
                0x34,0x31,0x43,0x35,0x32,0x45,0x32,0x35,
                0x34,0x34,0x37,0x43,0x42,0x32,0x38,0x46,
                0x34,0x34,0x42,0x38,0x38,0x36,0x46,0x41,
                0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,
                0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,
                0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,
                0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,
                0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,
                0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,

                //Starting Date/Time
                0x32,0x30,0x30,0x31,0x30,0x36,0x31,0x34,0x31,0x39,
                //Ending Date/Time
                0x32,0x30,0x30,0x31,0x30,0x36,0x31,0x34,0x32,0x31,
                //Number of eight character Data Fields to follow (Hex)
                0x31,0x30,
                0x34,0x34,0x44,0x44,0x39,0x37,0x44,0x45,
                0x34,0x34,0x44,0x43,0x32,0x45,0x44,0x42,
                0x34,0x33,0x44,0x42,0x38,0x39,0x42,0x45,
                0x34,0x31,0x43,0x35,0x32,0x43,0x42,0x41,
                0x34,0x34,0x46,0x41,0x30,0x30,0x30,0x30,
                0x34,0x34,0x46,0x38,0x36,0x38,0x41,0x45,
                0x34,0x33,0x46,0x45,0x41,0x43,0x37,0x46,
                0x34,0x31,0x43,0x35,0x32,0x45,0x32,0x35,
                0x34,0x34,0x37,0x43,0x42,0x32,0x38,0x46,
                0x34,0x34,0x42,0x38,0x38,0x36,0x46,0x41,
                0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,
                0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,
                0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,
                0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,
                0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,
                0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,


                //================================================
                //Tank Number (Decimal, 00=all)
                0x30, 0x32,
                //Product Code (one ASCII character [20h-7Eh])
                0x32,
                //Number of Deliveries to follow (Decimal, 00 if no data available for this tank)
                0x30,0x30,       


                //================================================
                //Tank Number (Decimal, 00=all)
                0x30, 0x33,
                //Product Code (one ASCII character [20h-7Eh])
                0x33,
                //Number of Deliveries to follow (Decimal, 00 if no data available for this tank)
                0x30,0x31,
                //Starting Date/Time
                0x32,0x30,0x30,0x31,0x30,0x36,0x31,0x34,0x31,0x39,
                //Ending Date/Time
                0x32,0x30,0x30,0x31,0x30,0x36,0x31,0x34,0x32,0x31,
                //Number of eight character Data Fields to follow (Hex)
                0x31,0x30,
                0x34,0x34,0x44,0x44,0x39,0x37,0x44,0x45,
                0x34,0x34,0x44,0x43,0x32,0x45,0x44,0x42,
                0x34,0x33,0x44,0x42,0x38,0x39,0x42,0x45,
                0x34,0x31,0x43,0x35,0x32,0x43,0x42,0x41,
                0x34,0x34,0x46,0x41,0x30,0x30,0x30,0x30,
                0x34,0x34,0x46,0x38,0x36,0x38,0x41,0x45,
                0x34,0x33,0x46,0x45,0x41,0x43,0x37,0x46,
                0x34,0x31,0x43,0x35,0x32,0x45,0x32,0x35,
                0x34,0x34,0x37,0x43,0x42,0x32,0x38,0x46,
                0x34,0x34,0x42,0x38,0x38,0x36,0x46,0x41,
                0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,
                0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,
                0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,
                0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,
                0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,
                0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,


                //================================================
                //Tank Number (Decimal, 00=all)
                0x30, 0x34,
                //Product Code (one ASCII character [20h-7Eh])
                0x34,
                //Number of Deliveries to follow (Decimal, 00 if no data available for this tank)
                0x30,0x31,
                //Starting Date/Time
                0x32,0x30,0x30,0x31,0x30,0x36,0x31,0x34,0x31,0x39,
                //Ending Date/Time
                0x32,0x30,0x30,0x31,0x30,0x36,0x31,0x34,0x32,0x31,
                //Number of eight character Data Fields to follow (Hex)
                0x31,0x30,
                0x34,0x34,0x44,0x44,0x39,0x37,0x44,0x45,
                0x34,0x34,0x44,0x43,0x32,0x45,0x44,0x42,
                0x34,0x33,0x44,0x42,0x38,0x39,0x42,0x45,
                0x34,0x31,0x43,0x35,0x32,0x43,0x42,0x41,
                0x34,0x34,0x46,0x41,0x30,0x30,0x30,0x30,
                0x34,0x34,0x46,0x38,0x36,0x38,0x41,0x45,
                0x34,0x33,0x46,0x45,0x41,0x43,0x37,0x46,
                0x34,0x31,0x43,0x35,0x32,0x45,0x32,0x35,
                0x34,0x34,0x37,0x43,0x42,0x32,0x38,0x46,
                0x34,0x34,0x42,0x38,0x38,0x36,0x46,0x41,
                0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,
                0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,
                0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,
                0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,
                0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,
                0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,



                //&& - Data Termination Flag
                0x26, 0x26, 
                //CCCC - Message Checksum
                0x45, 0x45, 0x41, 0x39, 
                //ETX
                0x03 };

            var response = new QueryInTankMostRecentDeliveryReportResponse();
            var p = new VeederRoot_ATG_Console.Parser();
            var actual = p.Deserialize(raw.ToArray()) as QueryInTankMostRecentDeliveryReportResponse;
            Assert.AreEqual(true, actual != null);
            Assert.AreEqual(true, actual.TankNumberInFunctionCode == 0);
            Assert.AreEqual(true, actual.DeliveriesForTanks != null);
            Assert.AreEqual(true, actual.DeliveriesForTanks.Count == 4);
            for (int i = 0; i < actual.DeliveriesForTanks.Count; i++)
            {
                var deliveriesForOneTank = actual.DeliveriesForTanks[i];
                Assert.AreEqual(true, deliveriesForOneTank.TankNumber == i + 1);
                Assert.AreEqual(true, deliveriesForOneTank.ProductCode == char.Parse((i + 1).ToString()));
                if (deliveriesForOneTank.TankNumber == 2)
                    Assert.AreEqual(true, deliveriesForOneTank.Deliveries == null);
                else
                    Assert.AreEqual(true, deliveriesForOneTank.Deliveries != null);

                if (deliveriesForOneTank.TankNumber == 1)
                    Assert.AreEqual(true, deliveriesForOneTank.Deliveries.Count == 2);
                else if (deliveriesForOneTank.TankNumber == 2)
                    Assert.AreEqual(true, deliveriesForOneTank.Deliveries == null);
                else
                    Assert.AreEqual(true, deliveriesForOneTank.Deliveries.Count == 1);
                if (deliveriesForOneTank.Deliveries != null)
                    foreach (var delivery in deliveriesForOneTank.Deliveries)
                    {
                        //foreach (var deliveryReadingDataName in delivery.Datas.Keys)
                        //{
                        //    var _ = delivery.Datas[deliveryReadingDataName];
                        //}
                        Assert.AreEqual(true,
                            delivery.Datas.TryGetValue(
                                Edge.Core.IndustryStandardInterface.ATG.DeliveryReadingDataName.StartingVolume,
                                out double startingVolumeRead));
                        Assert.AreEqual(true, startingVolumeRead
                            == VeederRoot_ATG_Console.Util.ConvertIEEEWith4BytesToDouble(
                                new byte[] { 
                                //0x34,0x34,0x44,0x44,0x39,0x37,0x44,0x45,
                                0x44, 0xDD, 0x97, 0xDE }));

                        Assert.AreEqual(true,
                            delivery.Datas.TryGetValue(
                                Edge.Core.IndustryStandardInterface.ATG.DeliveryReadingDataName.StartingTcVolume,
                                out double startingTcVolumeRead));
                        Assert.AreEqual(true, startingTcVolumeRead
                            == VeederRoot_ATG_Console.Util.ConvertIEEEWith4BytesToDouble(
                                new byte[] { 
                                //0x34,0x34,0x44,0x43,0x32,0x45,0x44,0x42,
                                0x44, 0xDC, 0x2E, 0xDB }));

                        Assert.AreEqual(true,
                            delivery.Datas.TryGetValue(
                                Edge.Core.IndustryStandardInterface.ATG.DeliveryReadingDataName.StartingHeight,
                                out double startingHeightRead));
                        Assert.AreEqual(true, startingHeightRead
                            == VeederRoot_ATG_Console.Util.ConvertIEEEWith4BytesToDouble(
                                new byte[] { 
                                //0x34,0x34,0x37,0x43,0x42,0x32,0x38,0x46,
                                0x44, 0x7C, 0xB2, 0x8F }));

                        Assert.AreEqual(true,
                            delivery.Datas.TryGetValue(
                                Edge.Core.IndustryStandardInterface.ATG.DeliveryReadingDataName.EndingHeight,
                                out double endingHeightRead));
                        Assert.AreEqual(true, endingHeightRead
                            == VeederRoot_ATG_Console.Util.ConvertIEEEWith4BytesToDouble(
                                new byte[] { 
                                //0x34,0x34,0x42,0x38,0x38,0x36,0x46,0x41,
                                0x44, 0xB8, 0x86, 0xFA }));

                    }
            }
        }

        [TestMethod]
        public void QueryInTankMostRecentDeliveryReportResponse_TestMethod4()
        {
            var raw = new byte[] { 
                //SOH
                0x01, 
                //Function Code (4 bytes) + TT (2 bytes)
                0x69, 0x32, 0x30, 0x43, 0x30, 0x30, 
                //Current Date and Time
                0x31, 0x38, 0x30, 0x35, 0x31, 0x30, 0x30, 0x36, 0x30, 0x33,

                //================================================
                //Tank Number (Decimal, 00=all)
                0x30, 0x31,
                //Product Code (one ASCII character [20h-7Eh])
                0x31,
                //Number of Deliveries to follow (Decimal, 00 if no data available for this tank)
                0x30,0x32,
                //Starting Date/Time
                0x32,0x30,0x30,0x31,0x30,0x36,0x31,0x34,0x31,0x39,
                //Ending Date/Time
                0x32,0x30,0x30,0x31,0x30,0x36,0x31,0x34,0x32,0x31,
                //Number of eight character Data Fields to follow (Hex)
                0x30,0x39,
                0x34,0x34,0x44,0x44,0x39,0x37,0x44,0x45,
                0x34,0x34,0x44,0x43,0x32,0x45,0x44,0x42,
                0x34,0x33,0x44,0x42,0x38,0x39,0x42,0x45,
                0x34,0x31,0x43,0x35,0x32,0x43,0x42,0x41,
                0x34,0x34,0x46,0x41,0x30,0x30,0x30,0x30,
                0x34,0x34,0x46,0x38,0x36,0x38,0x41,0x45,
                0x34,0x33,0x46,0x45,0x41,0x43,0x37,0x46,
                0x34,0x31,0x43,0x35,0x32,0x45,0x32,0x35,
                0x34,0x34,0x37,0x43,0x42,0x32,0x38,0x46,
                //0x34,0x34,0x42,0x38,0x38,0x36,0x46,0x41,

                //Starting Date/Time
                0x32,0x30,0x30,0x31,0x30,0x36,0x31,0x34,0x31,0x39,
                //Ending Date/Time
                0x32,0x30,0x30,0x31,0x30,0x36,0x31,0x34,0x32,0x31,
                //Number of eight character Data Fields to follow (Hex)
                0x30,0x39,
                0x34,0x34,0x44,0x44,0x39,0x37,0x44,0x45,
                0x34,0x34,0x44,0x43,0x32,0x45,0x44,0x42,
                0x34,0x33,0x44,0x42,0x38,0x39,0x42,0x45,
                0x34,0x31,0x43,0x35,0x32,0x43,0x42,0x41,
                0x34,0x34,0x46,0x41,0x30,0x30,0x30,0x30,
                0x34,0x34,0x46,0x38,0x36,0x38,0x41,0x45,
                0x34,0x33,0x46,0x45,0x41,0x43,0x37,0x46,
                0x34,0x31,0x43,0x35,0x32,0x45,0x32,0x35,
                0x34,0x34,0x37,0x43,0x42,0x32,0x38,0x46,


                //================================================
                //Tank Number (Decimal, 00=all)
                0x30, 0x32,
                //Product Code (one ASCII character [20h-7Eh])
                0x32,
                //Number of Deliveries to follow (Decimal, 00 if no data available for this tank)
                0x30,0x30,       


                //================================================
                //Tank Number (Decimal, 00=all)
                0x30, 0x33,
                //Product Code (one ASCII character [20h-7Eh])
                0x33,
                //Number of Deliveries to follow (Decimal, 00 if no data available for this tank)
                0x30,0x31,
                //Starting Date/Time
                0x32,0x30,0x30,0x31,0x30,0x36,0x31,0x34,0x31,0x39,
                //Ending Date/Time
                0x32,0x30,0x30,0x31,0x30,0x36,0x31,0x34,0x32,0x31,
                //Number of eight character Data Fields to follow (Hex)
                0x31,0x30,
                0x34,0x34,0x44,0x44,0x39,0x37,0x44,0x45,
                0x34,0x34,0x44,0x43,0x32,0x45,0x44,0x42,
                0x34,0x33,0x44,0x42,0x38,0x39,0x42,0x45,
                0x34,0x31,0x43,0x35,0x32,0x43,0x42,0x41,
                0x34,0x34,0x46,0x41,0x30,0x30,0x30,0x30,
                0x34,0x34,0x46,0x38,0x36,0x38,0x41,0x45,
                0x34,0x33,0x46,0x45,0x41,0x43,0x37,0x46,
                0x34,0x31,0x43,0x35,0x32,0x45,0x32,0x35,
                0x34,0x34,0x37,0x43,0x42,0x32,0x38,0x46,
                0x34,0x34,0x42,0x38,0x38,0x36,0x46,0x41,
                0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,
                0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,
                0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,
                0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,
                0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,
                0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,


                //================================================
                //Tank Number (Decimal, 00=all)
                0x30, 0x34,
                //Product Code (one ASCII character [20h-7Eh])
                0x34,
                //Number of Deliveries to follow (Decimal, 00 if no data available for this tank)
                0x30,0x31,
                //Starting Date/Time
                0x32,0x30,0x30,0x31,0x30,0x36,0x31,0x34,0x31,0x39,
                //Ending Date/Time
                0x32,0x30,0x30,0x31,0x30,0x36,0x31,0x34,0x32,0x31,
                //Number of eight character Data Fields to follow (Hex)
                0x31,0x30,
                0x34,0x34,0x44,0x44,0x39,0x37,0x44,0x45,
                0x34,0x34,0x44,0x43,0x32,0x45,0x44,0x42,
                0x34,0x33,0x44,0x42,0x38,0x39,0x42,0x45,
                0x34,0x31,0x43,0x35,0x32,0x43,0x42,0x41,
                0x34,0x34,0x46,0x41,0x30,0x30,0x30,0x30,
                0x34,0x34,0x46,0x38,0x36,0x38,0x41,0x45,
                0x34,0x33,0x46,0x45,0x41,0x43,0x37,0x46,
                0x34,0x31,0x43,0x35,0x32,0x45,0x32,0x35,
                0x34,0x34,0x37,0x43,0x42,0x32,0x38,0x46,
                0x34,0x34,0x42,0x38,0x38,0x36,0x46,0x41,
                0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,
                0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,
                0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,
                0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,
                0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,
                0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,



                //&& - Data Termination Flag
                0x26, 0x26, 
                //CCCC - Message Checksum
                0x45, 0x45, 0x41, 0x39, 
                //ETX
                0x03 };

            var response = new QueryInTankMostRecentDeliveryReportResponse();
            var p = new VeederRoot_ATG_Console.Parser();
            var actual = p.Deserialize(raw.ToArray()) as QueryInTankMostRecentDeliveryReportResponse;
            Assert.AreEqual(true, actual != null);
            Assert.AreEqual(true, actual.TankNumberInFunctionCode == 0);
            Assert.AreEqual(true, actual.DeliveriesForTanks != null);
            Assert.AreEqual(true, actual.DeliveriesForTanks.Count == 4);
            for (int i = 0; i < actual.DeliveriesForTanks.Count; i++)
            {
                var deliveriesForOneTank = actual.DeliveriesForTanks[i];
                Assert.AreEqual(true, deliveriesForOneTank.TankNumber == i + 1);
                Assert.AreEqual(true, deliveriesForOneTank.ProductCode == char.Parse((i + 1).ToString()));
                if (deliveriesForOneTank.TankNumber == 2)
                    Assert.AreEqual(true, deliveriesForOneTank.Deliveries == null);
                else
                    Assert.AreEqual(true, deliveriesForOneTank.Deliveries != null);

                if (deliveriesForOneTank.TankNumber == 1)
                    Assert.AreEqual(true, deliveriesForOneTank.Deliveries.Count == 2);
                else if (deliveriesForOneTank.TankNumber == 2)
                    Assert.AreEqual(true, deliveriesForOneTank.Deliveries == null);
                else
                    Assert.AreEqual(true, deliveriesForOneTank.Deliveries.Count == 1);
                if (deliveriesForOneTank.Deliveries != null)
                    foreach (var delivery in deliveriesForOneTank.Deliveries)
                    {
                        //foreach (var deliveryReadingDataName in delivery.Datas.Keys)
                        //{
                        //    var _ = delivery.Datas[deliveryReadingDataName];
                        //}
                        Assert.AreEqual(true,
                            delivery.Datas.TryGetValue(
                                Edge.Core.IndustryStandardInterface.ATG.DeliveryReadingDataName.StartingVolume,
                                out double startingVolumeRead));
                        Assert.AreEqual(true, startingVolumeRead
                            == VeederRoot_ATG_Console.Util.ConvertIEEEWith4BytesToDouble(
                                new byte[] { 
                                //0x34,0x34,0x44,0x44,0x39,0x37,0x44,0x45,
                                0x44, 0xDD, 0x97, 0xDE }));

                        Assert.AreEqual(true,
                            delivery.Datas.TryGetValue(
                                Edge.Core.IndustryStandardInterface.ATG.DeliveryReadingDataName.StartingTcVolume,
                                out double startingTcVolumeRead));
                        Assert.AreEqual(true, startingTcVolumeRead
                            == VeederRoot_ATG_Console.Util.ConvertIEEEWith4BytesToDouble(
                                new byte[] { 
                                //0x34,0x34,0x44,0x43,0x32,0x45,0x44,0x42,
                                0x44, 0xDC, 0x2E, 0xDB }));

                        Assert.AreEqual(true,
                            delivery.Datas.TryGetValue(
                                Edge.Core.IndustryStandardInterface.ATG.DeliveryReadingDataName.StartingHeight,
                                out double startingHeightRead));
                        Assert.AreEqual(true, startingHeightRead
                            == VeederRoot_ATG_Console.Util.ConvertIEEEWith4BytesToDouble(
                                new byte[] { 
                                //0x34,0x34,0x37,0x43,0x42,0x32,0x38,0x46,
                                0x44, 0x7C, 0xB2, 0x8F }));

                        if (deliveriesForOneTank.TankNumber == 1)
                        {
                            Assert.AreEqual(false,
                                delivery.Datas.TryGetValue(
                                    Edge.Core.IndustryStandardInterface.ATG.DeliveryReadingDataName.EndingHeight,
                                    out double endingHeightRead));
                        }
                        else
                        {
                            Assert.AreEqual(true,
                                delivery.Datas.TryGetValue(
                                    Edge.Core.IndustryStandardInterface.ATG.DeliveryReadingDataName.EndingHeight,
                                    out double endingHeightRead), $"Tank with number: {deliveriesForOneTank.TankNumber} does not have EndingHeight read");
                            Assert.AreEqual(true, endingHeightRead
                                == VeederRoot_ATG_Console.Util.ConvertIEEEWith4BytesToDouble(
                                    new byte[] { 
                                //0x34,0x34,0x42,0x38,0x38,0x36,0x46,0x41,
                                0x44, 0xB8, 0x86, 0xFA }));
                        }
                    }
            }
        }


        [TestMethod]
        public void QueryInTankStatusReportResponse_TestMethod1()
        {
            var raw = new byte[] { 
                //SOH
                0x01, 
                //Function Code (4 bytes) + TT (2 bytes)
                0x69,0x32,0x30,0x35,0x30,0x30, 
                //Current Date and Time
                0x31,0x38,0x30,0x35,0x31,0x30,0x30,0x35,0x32,0x33,
                //Tank Number (Decimal, 00=all)
                0x30, 0x31,
                //Number of alarms active for tank (Hex, 00=none)
                0x30,0x31,
                //Alarm Type Number
                0x31,0x32,

                //&& - Data Termination Flag
                0x26, 0x26, 
                //CCCC - Message Checksum
                0x45, 0x45, 0x41, 0x39, 
                //ETX
                0x03 };

            var response = new QueryInTankStatusReportResponse();
            var p = new VeederRoot_ATG_Console.Parser();
            var actual = p.Deserialize(raw.ToArray()) as QueryInTankStatusReportResponse;
            Assert.AreEqual(true, actual != null);
            Assert.AreEqual(true, actual.TankNumberInFunctionCode == 0);
            Assert.AreEqual(true, actual.TanksOfAlarms != null);
            Assert.AreEqual(true, actual.TanksOfAlarms.Count == 1);
            Assert.AreEqual(true, actual.TanksOfAlarms.First().TankNumber == 1);
            Assert.AreEqual(true, actual.TanksOfAlarms.First().NumberOfAlarmsActiveForThisTank == 1);
            Assert.AreEqual(true, actual.TanksOfAlarms.First().Alarms != null);
            Assert.AreEqual(true, actual.TanksOfAlarms.First().Alarms.Count() == 1);
            Assert.AreEqual(true, actual.TanksOfAlarms.First().Alarms.First() == AlarmType.TankMaximumProductAlarm);
        }

        [TestMethod]
        public void QueryInTankStatusReportResponse_TestMethod2()
        {
            var raw = new byte[] { 
                //SOH
                0x01, 
                //Function Code (4 bytes) + TT (2 bytes)
                0x69,0x32,0x30,0x35,0x30,0x30, 
                //Current Date and Time
                0x31,0x38,0x30,0x35,0x31,0x30,0x30,0x35,0x32,0x33,
                //Tank Number (Decimal, 00=all)
                0x30, 0x31,
                //Number of alarms active for tank (Hex, 00=none)
                0x30,0x32,
                //Alarm Type Number
                0x31,0x32,
                0x31,0x33,


                //&& - Data Termination Flag
                0x26, 0x26, 
                //CCCC - Message Checksum
                0x45, 0x45, 0x41, 0x39, 
                //ETX
                0x03 };

            var response = new QueryInTankStatusReportResponse();
            var p = new VeederRoot_ATG_Console.Parser();
            var actual = p.Deserialize(raw.ToArray()) as QueryInTankStatusReportResponse;
            Assert.AreEqual(true, actual != null);
            Assert.AreEqual(true, actual.TankNumberInFunctionCode == 0);
            Assert.AreEqual(true, actual.TanksOfAlarms != null);
            Assert.AreEqual(true, actual.TanksOfAlarms.Count == 1);
            Assert.AreEqual(true, actual.TanksOfAlarms.First().TankNumber == 1);
            Assert.AreEqual(true, actual.TanksOfAlarms.First().NumberOfAlarmsActiveForThisTank == 2);
            Assert.AreEqual(true, actual.TanksOfAlarms.First().Alarms != null);
            Assert.AreEqual(true, actual.TanksOfAlarms.First().Alarms.Count() == 2);
            Assert.AreEqual(true, actual.TanksOfAlarms.First().Alarms.First() == AlarmType.TankMaximumProductAlarm);
            Assert.AreEqual(true, actual.TanksOfAlarms.First().Alarms.Skip(1).First() == AlarmType.TankGrossLeakTestFailAlarm);
        }

        [TestMethod]
        public void QueryInTankStatusReportResponse_TestMethod3()
        {
            var raw = new byte[] { 
                //SOH
                0x01, 
                //Function Code (4 bytes) + TT (2 bytes)
                0x69,0x32,0x30,0x35,0x30,0x30, 
                //Current Date and Time
                0x31,0x38,0x30,0x35,0x31,0x30,0x30,0x35,0x32,0x33,
                //Tank Number (Decimal, 00=all)
                0x30, 0x31,
                //Number of alarms active for tank (Hex, 00=none)
                0x30,0x32,
                //Alarm Type Number
                0x31,0x32,
                0x31,0x33,

                //Tank Number (Decimal, 00=all)
                0x30, 0x32,
                //Number of alarms active for tank (Hex, 00=none)
                0x30,0x32,
                //Alarm Type Number
                0x31,0x32,
                0x31,0x33,


                //&& - Data Termination Flag
                0x26, 0x26, 
                //CCCC - Message Checksum
                0x45, 0x45, 0x41, 0x39, 
                //ETX
                0x03 };

            var response = new QueryInTankStatusReportResponse();
            var p = new VeederRoot_ATG_Console.Parser();
            var actual = p.Deserialize(raw.ToArray()) as QueryInTankStatusReportResponse;
            Assert.AreEqual(true, actual != null);
            Assert.AreEqual(true, actual.TankNumberInFunctionCode == 0);
            Assert.AreEqual(true, actual.TanksOfAlarms != null);
            Assert.AreEqual(true, actual.TanksOfAlarms.Count == 2);

            var firstTank = actual.TanksOfAlarms.First();
            Assert.AreEqual(true, firstTank.TankNumber == 1);
            Assert.AreEqual(true, firstTank.NumberOfAlarmsActiveForThisTank == 2);
            Assert.AreEqual(true, firstTank.Alarms != null);
            Assert.AreEqual(true, firstTank.Alarms.Count() == 2);
            Assert.AreEqual(true, firstTank.Alarms.First() == AlarmType.TankMaximumProductAlarm);
            Assert.AreEqual(true, firstTank.Alarms.Skip(1).First() == AlarmType.TankGrossLeakTestFailAlarm);

            var secondTank = actual.TanksOfAlarms.Skip(1).First();
            Assert.AreEqual(true, secondTank.TankNumber == 2);
            Assert.AreEqual(true, secondTank.NumberOfAlarmsActiveForThisTank == 2);
            Assert.AreEqual(true, secondTank.Alarms != null);
            Assert.AreEqual(true, secondTank.Alarms.Count() == 2);
            Assert.AreEqual(true, secondTank.Alarms.First() == AlarmType.TankMaximumProductAlarm);
            Assert.AreEqual(true, secondTank.Alarms.Skip(1).First() == AlarmType.TankGrossLeakTestFailAlarm);

        }

        [TestMethod]
        public void QueryInTankStatusReportResponse_TestMethod4()
        {
            var raw = new byte[] { 
                //SOH
                0x01, 
                //Function Code (4 bytes) + TT (2 bytes)
                0x69,0x32,0x30,0x35,0x30,0x30, 
                //Current Date and Time
                0x31,0x38,0x30,0x35,0x31,0x30,0x30,0x35,0x32,0x33,
                //Tank Number (Decimal, 00=all)
                0x30, 0x31,
                //Number of alarms active for tank (Hex, 00=none)
                0x30,0x32,
                //Alarm Type Number
                0x31,0x32,
                0x31,0x33,

                //Tank Number (Decimal, 00=all)
                0x30, 0x32,
                //Number of alarms active for tank (Hex, 00=none)
                0x30,0x32,
                //Alarm Type Number
                0x31,0x32,
                0x31,0x33,

                //Tank Number (Decimal, 00=all)
                0x30, 0x33,
                //Number of alarms active for tank (Hex, 00=none)
                0x30,0x33,
                //Alarm Type Number
                0x31,0x32,
                0x31,0x33,
                0x31,0x34,

                //Tank Number (Decimal, 00=all)
                0x30, 0x34,
                //Number of alarms active for tank (Hex, 00=none)
                0x30,0x36,
                //Alarm Type Number
                0x31,0x32,
                0x31,0x33,
                0x31,0x34,
                0x31,0x34,
                0x31,0x34,
                0x32,0x39,

                //&& - Data Termination Flag
                0x26, 0x26, 
                //CCCC - Message Checksum
                0x45, 0x45, 0x41, 0x39, 
                //ETX
                0x03 };

            var response = new QueryInTankStatusReportResponse();
            var p = new VeederRoot_ATG_Console.Parser();
            var actual = p.Deserialize(raw.ToArray()) as QueryInTankStatusReportResponse;
            Assert.AreEqual(true, actual != null);
            Assert.AreEqual(true, actual.TankNumberInFunctionCode == 0);
            Assert.AreEqual(true, actual.TanksOfAlarms != null);
            Assert.AreEqual(true, actual.TanksOfAlarms.Count == 4);

            var firstTank = actual.TanksOfAlarms.First();
            Assert.AreEqual(true, firstTank.TankNumber == 1);
            Assert.AreEqual(true, firstTank.NumberOfAlarmsActiveForThisTank == 2);
            Assert.AreEqual(true, firstTank.Alarms != null);
            Assert.AreEqual(true, firstTank.Alarms.Count() == 2);
            Assert.AreEqual(true, firstTank.Alarms.First() == AlarmType.TankMaximumProductAlarm);
            Assert.AreEqual(true, firstTank.Alarms.Skip(1).First() == AlarmType.TankGrossLeakTestFailAlarm);

            var secondTank = actual.TanksOfAlarms.Skip(1).First();
            Assert.AreEqual(true, secondTank.TankNumber == 2);
            Assert.AreEqual(true, secondTank.NumberOfAlarmsActiveForThisTank == 2);
            Assert.AreEqual(true, secondTank.Alarms != null);
            Assert.AreEqual(true, secondTank.Alarms.Count() == 2);
            Assert.AreEqual(true, secondTank.Alarms.First() == AlarmType.TankMaximumProductAlarm);
            Assert.AreEqual(true, secondTank.Alarms.Skip(1).First() == AlarmType.TankGrossLeakTestFailAlarm);

            var thirdTank = actual.TanksOfAlarms.Skip(2).First();
            Assert.AreEqual(true, thirdTank.TankNumber == 3);
            Assert.AreEqual(true, thirdTank.NumberOfAlarmsActiveForThisTank == 3);
            Assert.AreEqual(true, thirdTank.Alarms != null);
            Assert.AreEqual(true, thirdTank.Alarms.Count() == 3);
            Assert.AreEqual(true, thirdTank.Alarms.First() == AlarmType.TankMaximumProductAlarm);
            Assert.AreEqual(true, thirdTank.Alarms.Skip(1).First() == AlarmType.TankGrossLeakTestFailAlarm);
            Assert.AreEqual(true, thirdTank.Alarms.Skip(2).First() == AlarmType.TankPeriodicLeakTestFailAlarm);

            var fourthTank = actual.TanksOfAlarms.Skip(3).First();
            Assert.AreEqual(true, fourthTank.TankNumber == 4);
            Assert.AreEqual(true, fourthTank.NumberOfAlarmsActiveForThisTank == 6);
            Assert.AreEqual(true, fourthTank.Alarms != null);
            Assert.AreEqual(true, fourthTank.Alarms.Count() == 6);
            Assert.AreEqual(true, fourthTank.Alarms.First() == AlarmType.TankMaximumProductAlarm);
            Assert.AreEqual(true, fourthTank.Alarms.Skip(1).First() == AlarmType.TankGrossLeakTestFailAlarm);
            Assert.AreEqual(true, fourthTank.Alarms.Skip(2).First() == AlarmType.TankPeriodicLeakTestFailAlarm);
            Assert.AreEqual(true, fourthTank.Alarms.Last() == AlarmType.TankLineGrossLeakAlarm);

        }

        [TestMethod]
        public void QueryOrSetTankProductLabelResponse_TestMethod1()
        {
            var raw = new byte[] { 
                //SOH
                0x01, 
                //Function Code (4 bytes) + TT (2 bytes)
                0x69,0x36,0x30,0x32,0x30,0x30,
                //Current Date and Time
                0x31,0x38,0x30,0x35,0x31,0x30,0x30,0x35,0x32,0x33,
                
                //Tank Number (Decimal, 00=all)
                0x30,0x31,
                //Product Label (20 ASCII characters [20h-7Eh])
                0x74,0x61,0x6E,0x6B,0x31,0x20,0x39,0x32,0x23,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,
                
                //&& - Data Termination Flag
                0x26, 0x26, 
                //CCCC - Message Checksum
                0x45, 0x45, 0x41, 0x39, 
                //ETX
                0x03 };

            var response = new QueryOrSetTankProductLabelResponse();
            var p = new VeederRoot_ATG_Console.Parser();
            var actual = p.Deserialize(raw.ToArray()) as QueryOrSetTankProductLabelResponse;
            Assert.AreEqual(true, actual != null);
            Assert.AreEqual(true, actual.TankNumberInFunctionCode == 0);
            Assert.AreEqual(true, actual.ProductLabels != null);
            Assert.AreEqual(true, actual.ProductLabels.Count() == 1);

            Assert.AreEqual(true, actual.ProductLabels.First().Item1 == 1);
            Assert.AreEqual(true, actual.ProductLabels.First().Item2 == Encoding.ASCII.GetString(new byte[] { 0x74, 0x61, 0x6E, 0x6B, 0x31, 0x20, 0x39, 0x32, 0x23, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, }));

        }

        [TestMethod]
        public void QueryOrSetTankProductLabelResponse_TestMethod3()
        {
            var raw = new byte[] { 
                //SOH
                0x01, 
                //Function Code (4 bytes) + TT (2 bytes)
                0x69,0x36,0x30,0x32,0x30,0x30,
                //Current Date and Time
                0x31,0x38,0x30,0x35,0x31,0x30,0x30,0x35,0x32,0x33,
                
                //Tank Number (Decimal, 00=all)
                0x30,0x31,
                //Product Label (20 ASCII characters [20h-7Eh])
                0x74,0x61,0x6E,0x6B,0x31,0x20,0x39,0x32,0x23,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,

                //Tank Number (Decimal, 00=all)
                0x30,0x32,
                //Product Label (20 ASCII characters [20h-7Eh])
                0x31,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,

                //Tank Number (Decimal, 00=all)
                0x30,0x33,
                //Product Label (20 ASCII characters [20h-7Eh])
                0x32,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,

                //Tank Number (Decimal, 00=all)
                0x30,0x34,
                //Product Label (20 ASCII characters [20h-7Eh])
                0x33,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,

                //Tank Number (Decimal, 00=all)
                0x30,0x35,
                //Product Label (20 ASCII characters [20h-7Eh])
                0x34,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,

                //Tank Number (Decimal, 00=all)
                0x30,0x36,
                0x35,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,

                //&& - Data Termination Flag
                0x26, 0x26, 
                //CCCC - Message Checksum
                0x45, 0x45, 0x41, 0x39, 
                //ETX
                0x03 };

            var response = new QueryOrSetTankProductLabelResponse();
            var p = new VeederRoot_ATG_Console.Parser();
            var actual = p.Deserialize(raw.ToArray()) as QueryOrSetTankProductLabelResponse;
            Assert.AreEqual(true, actual != null);
            Assert.AreEqual(true, actual.TankNumberInFunctionCode == 0);
            Assert.AreEqual(true, actual.ProductLabels != null);
            Assert.AreEqual(true, actual.ProductLabels.Count() == 6);

            Assert.AreEqual(true, actual.ProductLabels.First().Item1 == 1);
            Assert.AreEqual(true, actual.ProductLabels.First().Item2 == Encoding.ASCII.GetString(new byte[] { 0x74, 0x61, 0x6E, 0x6B, 0x31, 0x20, 0x39, 0x32, 0x23, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, }));

            Assert.AreEqual(true, actual.ProductLabels.Skip(1).First().Item1 == 2);
            Assert.AreEqual(true, actual.ProductLabels.Skip(1).First().Item2 == Encoding.ASCII.GetString(new byte[] { 0x31, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, }));

            Assert.AreEqual(true, actual.ProductLabels.Skip(2).First().Item1 == 3);
            Assert.AreEqual(true, actual.ProductLabels.Skip(2).First().Item2 == Encoding.ASCII.GetString(new byte[] { 0x32, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, }));

            Assert.AreEqual(true, actual.ProductLabels.Skip(3).First().Item1 == 4);
            Assert.AreEqual(true, actual.ProductLabels.Skip(3).First().Item2 == Encoding.ASCII.GetString(new byte[] { 0x33, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, }));

            Assert.AreEqual(true, actual.ProductLabels.Skip(4).First().Item1 == 5);
            Assert.AreEqual(true, actual.ProductLabels.Skip(4).First().Item2 == Encoding.ASCII.GetString(new byte[] { 0x34, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, }));

            Assert.AreEqual(true, actual.ProductLabels.Skip(5).First().Item1 == 6);
            Assert.AreEqual(true, actual.ProductLabels.Skip(5).First().Item2 == Encoding.ASCII.GetString(new byte[] { 0x35, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, }));
        }


        [TestMethod]
        public void QueryOrSetTankDiameterResponse_TestMethod1()
        {
            var raw = new byte[] { 
                //SOH
                0x01, 
                //Function Code (4 bytes) + TT (2 bytes)
                0x69,0x36,0x30,0x37,0x30,0x30,
                //Current Date and Time
                0x31,0x38,0x30,0x35,0x31,0x30,0x30,0x35,0x32,0x33,
                
                //Tank Number (Decimal, 00=all)
                0x30,0x31,
                //Tank Diameter, Inches (ASCII Hex IEEE float)
                0x34,0x34,0x39,0x38,0x36,0x36,0x36,0x36,
                
                //&& - Data Termination Flag
                0x26, 0x26, 
                //CCCC - Message Checksum
                0x45, 0x45, 0x41, 0x39, 
                //ETX
                0x03 };

            var response = new QueryOrSetTankDiameterResponse();
            var p = new VeederRoot_ATG_Console.Parser();
            var actual = p.Deserialize(raw.ToArray()) as QueryOrSetTankDiameterResponse;
            Assert.AreEqual(true, actual != null);
            Assert.AreEqual(true, actual.TankNumberInFunctionCode == 0);
            Assert.AreEqual(true, actual.Diameters != null);
            Assert.AreEqual(true, actual.Diameters.Count() == 1);

            Assert.AreEqual(true, actual.Diameters.First().Item1 == 1);
            Assert.AreEqual(true, actual.Diameters.First().Item2 ==
                VeederRoot_ATG_Console.Util.ConvertIEEEWith4BytesToDouble(
                    VeederRoot_ATG_Console.Util.ConvertHexBcdStrToBytes(
                        new byte[] { 0x34, 0x34, 0x39, 0x38, 0x36, 0x36, 0x36, 0x36, }).ToArray()));

        }

        [TestMethod]
        public void QueryOrSetTankDiameterResponse_TestMethod3()
        {
            var raw = new byte[] { 
                //SOH
                0x01, 
                //Function Code (4 bytes) + TT (2 bytes)
                0x69,0x36,0x30,0x37,0x30,0x30,
                //Current Date and Time
                0x31,0x38,0x30,0x35,0x31,0x30,0x30,0x35,0x32,0x33,
                
                //Tank Number (Decimal, 00=all)
                0x30,0x31,
                //Tank Diameter, Inches (ASCII Hex IEEE float)
                0x34,0x34,0x39,0x38,0x36,0x36,0x36,0x36,

                0x30,0x32,
                0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,

                0x30,0x33,
                0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,

                0x30,0x34,
                0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,

                0x30,0x35,
                0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,

                0x30,0x36,
                0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,

                //&& - Data Termination Flag
                0x26, 0x26, 
                //CCCC - Message Checksum
                0x45, 0x45, 0x41, 0x39, 
                //ETX
                0x03 };

            var response = new QueryOrSetTankDiameterResponse();
            var p = new VeederRoot_ATG_Console.Parser();
            var actual = p.Deserialize(raw.ToArray()) as QueryOrSetTankDiameterResponse;
            Assert.AreEqual(true, actual != null);
            Assert.AreEqual(true, actual.TankNumberInFunctionCode == 0);
            Assert.AreEqual(true, actual.Diameters != null);
            Assert.AreEqual(true, actual.Diameters.Count() == 6);

            Assert.AreEqual(true, actual.Diameters.First().Item1 == 1);
            Assert.AreEqual(true, actual.Diameters.First().Item2 ==
                VeederRoot_ATG_Console.Util.ConvertIEEEWith4BytesToDouble(
                    VeederRoot_ATG_Console.Util.ConvertHexBcdStrToBytes(
                        new byte[] { 0x34, 0x34, 0x39, 0x38, 0x36, 0x36, 0x36, 0x36, }).ToArray()));

            for (int i = 1; i < actual.Diameters.Count(); i++)
            {
                Assert.AreEqual(true, actual.Diameters.ElementAt(i).Item1 == i + 1);
                Assert.AreEqual(true, actual.Diameters.ElementAt(i).Item2 == 0);
            }
        }

        [TestMethod]
        public void QueryInTankDiagnosticReportResponse_TestMethod1()
        {
            var raw = new byte[] { 
                //SOH
                0x01, 
                //Function Code (4 bytes) + TT (2 bytes)
                0x69,0x41,0x30,0x31,0x30,0x30,
                //Current Date and Time
                0x31,0x38,0x30,0x35,0x31,0x30,0x30,0x35,0x32,0x33,
                
                //TT - Tank Number (Decimal, 00=all)
                0x30,0x31,
                //Product Code (one ASCII character [20h-7Eh])
                0x31,
                //Probe Type
                0x30,0x33,
                //Circuit Code (Hex)
                0x44,0x30,0x30,0x36,
                //Probe Length (ASCII Hex IEEE float)
                0x34,0x34,0x46,0x41,0x44,0x33,0x33,0x33,
                //Probe Serial Number (Decimal)
                0x32,0x30,0x34,0x32,0x30,0x37,
                //Probe Date Code (Hex)
                0x31,0x32,0x39,0x35,
                
                //&& - Data Termination Flag
                0x26, 0x26, 
                //CCCC - Message Checksum
                0x45, 0x45, 0x41, 0x39, 
                //ETX
                0x03 };

            var response = new QueryInTankDiagnosticReportResponse();
            var p = new VeederRoot_ATG_Console.Parser();
            var actual = p.Deserialize(raw.ToArray()) as QueryInTankDiagnosticReportResponse;
            Assert.AreEqual(true, actual != null);
            Assert.AreEqual(true, actual.TankNumberInFunctionCode == 0);
            Assert.AreEqual(true, actual.Probes != null);
            Assert.AreEqual(true, actual.Probes.Count() == 1);

            Assert.AreEqual(true, actual.Probes.First().TankNumber == 1);
            Assert.AreEqual(true, actual.Probes.First().ProbeSerialNumber ==
                Encoding.ASCII.GetString(new byte[] { 0x32, 0x30, 0x34, 0x32, 0x30, 0x37 }));
            Assert.AreEqual(true, actual.Probes.First().ProbeLength ==
                VeederRoot_ATG_Console.Util.ConvertIEEEWith4BytesToDouble(
                    VeederRoot_ATG_Console.Util.ConvertHexBcdStrToBytes(
                        new byte[] { 0x34, 0x34, 0x46, 0x41, 0x44, 0x33, 0x33, 0x33, }).ToArray()));

        }

        [TestMethod]
        public void QueryInTankDiagnosticReportResponse_TestMethod3()
        {
            var raw = new byte[] { 
                //SOH
                0x01, 
                //Function Code (4 bytes) + TT (2 bytes)
                0x69,0x41,0x30,0x31,0x30,0x30,
                //Current Date and Time
                0x31,0x38,0x30,0x35,0x31,0x30,0x30,0x35,0x32,0x33,
                
                //TT - Tank Number (Decimal, 00=all)
                0x30,0x31,
                //Product Code (one ASCII character [20h-7Eh])
                0x31,
                //Probe Type
                0x30,0x33,
                //Circuit Code (Hex)
                0x44,0x30,0x30,0x36,
                //Probe Length (ASCII Hex IEEE float)
                0x34,0x34,0x46,0x41,0x44,0x33,0x33,0x33,
                //Probe Serial Number (Decimal)
                0x32,0x30,0x34,0x32,0x30,0x37,
                //Probe Date Code (Hex)
                0x31,0x32,0x39,0x35,

                //TT - Tank Number (Decimal, 00=all)
                0x30,0x32,
                //Product Code (one ASCII character [20h-7Eh])
                0x32,
                //Probe Type
                0x30,0x33,
                //Circuit Code (Hex)
                0x44,0x30,0x30,0x36,
                //Probe Length (ASCII Hex IEEE float)
                0x34,0x34,0x46,0x41,0x44,0x33,0x33,0x33,
                //Probe Serial Number (Decimal)
                0x32,0x30,0x34,0x32,0x30,0x38,
                //Probe Date Code (Hex)
                0x31,0x32,0x39,0x35,

                //TT - Tank Number (Decimal, 00=all)
                0x30,0x33,
                //Product Code (one ASCII character [20h-7Eh])
                0x33,
                //Probe Type
                0x30,0x33,
                //Circuit Code (Hex)
                0x44,0x30,0x30,0x36,
                //Probe Length (ASCII Hex IEEE float)
                0x34,0x34,0x46,0x41,0x44,0x33,0x33,0x33,
                //Probe Serial Number (Decimal)
                0x32,0x30,0x34,0x32,0x30,0x39,
                //Probe Date Code (Hex)
                0x31,0x32,0x39,0x35,
                
                //&& - Data Termination Flag
                0x26, 0x26, 
                //CCCC - Message Checksum
                0x45, 0x45, 0x41, 0x39, 
                //ETX
                0x03 };

            var response = new QueryInTankDiagnosticReportResponse();
            var p = new VeederRoot_ATG_Console.Parser();
            var actual = p.Deserialize(raw.ToArray()) as QueryInTankDiagnosticReportResponse;
            Assert.AreEqual(true, actual != null);
            Assert.AreEqual(true, actual.TankNumberInFunctionCode == 0);
            Assert.AreEqual(true, actual.Probes != null);
            Assert.AreEqual(true, actual.Probes.Count() == 3);

            Assert.AreEqual(true, actual.Probes.First().TankNumber == 1);
            Assert.AreEqual(true, actual.Probes.First().ProbeSerialNumber ==
                Encoding.ASCII.GetString(new byte[] { 0x32, 0x30, 0x34, 0x32, 0x30, 0x37 }));
            Assert.AreEqual(true, actual.Probes.First().ProbeLength ==
                VeederRoot_ATG_Console.Util.ConvertIEEEWith4BytesToDouble(
                    VeederRoot_ATG_Console.Util.ConvertHexBcdStrToBytes(
                        new byte[] { 0x34, 0x34, 0x46, 0x41, 0x44, 0x33, 0x33, 0x33, }).ToArray()));

            Assert.AreEqual(true, actual.Probes.Skip(1).First().TankNumber == 2);
            Assert.AreEqual(true, actual.Probes.Skip(1).First().ProbeSerialNumber ==
                Encoding.ASCII.GetString(new byte[] { 0x32, 0x30, 0x34, 0x32, 0x30, 0x38 }));
            Assert.AreEqual(true, actual.Probes.First().ProbeLength ==
                VeederRoot_ATG_Console.Util.ConvertIEEEWith4BytesToDouble(
                    VeederRoot_ATG_Console.Util.ConvertHexBcdStrToBytes(
                        new byte[] { 0x34, 0x34, 0x46, 0x41, 0x44, 0x33, 0x33, 0x33, }).ToArray()));

            Assert.AreEqual(true, actual.Probes.Skip(2).First().TankNumber == 3);
            Assert.AreEqual(true, actual.Probes.Skip(2).First().ProbeSerialNumber ==
                Encoding.ASCII.GetString(new byte[] { 0x32, 0x30, 0x34, 0x32, 0x30, 0x39 }));
            Assert.AreEqual(true, actual.Probes.First().ProbeLength ==
                VeederRoot_ATG_Console.Util.ConvertIEEEWith4BytesToDouble(
                    VeederRoot_ATG_Console.Util.ConvertHexBcdStrToBytes(
                        new byte[] { 0x34, 0x34, 0x46, 0x41, 0x44, 0x33, 0x33, 0x33, }).ToArray()));
        }

        [TestMethod]
        public void QueryInTankStatusReportRequest_TestMethod1()
        {
            var raw = new byte[] { 0x01, 0x69, 0x32, 0x30, 0x35, 0x30, 0x30, 0x31, 0x38, 0x30, 0x35, 0x31, 0x32, 0x30, 0x31, 0x32, 0x31, 0x30, 0x31, 0x30, 0x32, 0x31, 0x30, 0x30, 0x33, 0x26, 0x26, 0x46, 0x41, 0x44, 0x37, 0x03 };
            var response = new QueryInTankStatusReportResponse();
            var p = new VeederRoot_ATG_Console.Parser();
            var actual = p.Deserialize(raw.ToArray()) as QueryInTankStatusReportResponse;
            Assert.AreEqual(true, actual != null);
            Assert.AreEqual(true, actual.TankNumberInFunctionCode == 0);
            var alarmsForTanks = actual?.TanksOfAlarms.Select(ta =>
            {
                var alarms = new List<Edge.Core.IndustryStandardInterface.ATG.Alarm>();
                alarms.AddRange(ta?.Alarms.Select(aType => new Edge.Core.IndustryStandardInterface.ATG.Alarm()
                {
                    TankNumber = (byte)ta.TankNumber,
                    Priority = AlarmPriority.Alarm,
                    Type = aType,
                    CreatedTimeStamp = DateTime.Now,
                }));
                return alarms;
            });
            foreach (var alarmsForTank in alarmsForTanks)
            {
                var alarmEventArg = new AtgAlarmEventArg(
                    alarmsForTank.First().TankNumber,
                    alarmsForTank.Select(alarm => new Alarm()
                    {
                        TankNumber = alarmsForTank.First().TankNumber,
                        Priority = AlarmPriority.Alarm,
                        Type = alarm.Type,
                        CreatedTimeStamp = DateTime.Now,
                    }));
                Assert.AreEqual(true, alarmEventArg != null);
            }
        }
    }
}