FCC/Test/Devices/BatterySystems/SuZhouSuAnXin_BatteryEMS_Test/UnitTest1.cs

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

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

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

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

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

            var rawDataStr = "00 00 00 00 00 06 20 03 00 00 00 0A";
            var rawValid = rawDataStr.ToBytes();
            cutter.Feed(rawValid);
            Assert.AreEqual(true, onMsgCutCalledTimes == 1);
            Assert.AreEqual(true, messages.Count == 1);
            Assert.AreEqual(true, ValueEquals(messages[0], rawValid));
            Assert.AreEqual(true, onInvalidMsgCalledTimes == 0);
        }

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

            var rawDataStr = "00 00 00 00 00 17 20 03 14 11 22 33 44 55 66 77 88 99 00 11 22 33 44 55 66 77 88 99 00";
            var rawValid = rawDataStr.ToBytes();
            cutter.Feed(rawValid);
            Assert.AreEqual(true, onMsgCutCalledTimes == 1);
            Assert.AreEqual(true, messages.Count == 1);
            Assert.AreEqual(true, ValueEquals(messages[0], rawValid));
            Assert.AreEqual(true, onInvalidMsgCalledTimes == 0);
        }

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

            var rawDataStr = "00 00 00 00 00 06 20 03 00 00 00 0A " +
                "CC DD " +
                "00 00 00 00 00 17 20 03 14 11 22 33 44 55 66 77 88 99 00 11 22 33 44 55 66 77 88 99 00";
            var rawValid = rawDataStr.ToBytes();
            cutter.Feed(rawValid);
            Assert.AreEqual(true, onMsgCutCalledTimes == 2);
            Assert.AreEqual(true, messages.Count == 2);
            Assert.AreEqual(true, ValueEquals(messages[0], rawValid.Take(12)));
            Assert.AreEqual(true, onInvalidMsgCalledTimes == 2);
        }

        [TestMethod]
        public void OutgoingQueryMessageTest1()
        {
            var msg = new OutgoingQueryMessage(0, 10);
            var parser = new Parser();
            var actual = parser.Serialize(msg);
            var expect = new byte[] { 0x00,0x00,0x00,0x00,
            0x00,0x06,
            0x20,
            0x03,
            0x00,0x00,
            0x00,0x0A};
            Assert.AreEqual(true, ValueEquals(actual, expect), $"actual is: 0x{actual.ToHexLogString()}");
        }

        [TestMethod]
        public void OutgoingQueryMessageTest2()
        {
            var msg = new OutgoingQueryMessage(1, 10);
            var parser = new Parser();
            var actual = parser.Serialize(msg);
            var expect = new byte[] { 0x00,0x00,0x00,0x00,
            0x00,0x06,
            0x20,
            0x03,
            0x00,0x01,
            0x00,0x0A};
            Assert.AreEqual(true, ValueEquals(actual, expect), $"actual is: 0x{actual.ToHexLogString()}");
        }

        [TestMethod]
        public void OutgoingQueryMessageTest3()
        {
            var msg = new OutgoingQueryMessage(0x16, 1);
            var parser = new Parser();
            var actual = parser.Serialize(msg);
            var expect = new byte[] { 0x00,0x00,0x00,0x00,
            0x00,0x06,
            0x20,
            0x03,
            0x00,0x16,
            0x00,0x01};
            Assert.AreEqual(true, ValueEquals(actual, expect), $"actual is: 0x{actual.ToHexLogString()}");
        }

        [TestMethod]
        public void OutgoingQueryMessageTest4()
        {
            var msg = new OutgoingQueryMessage(0x0230, 1);
            var parser = new Parser();
            var actual = parser.Serialize(msg);
            var expect = new byte[] { 0x00,0x00,0x00,0x00,
            0x00,0x06,
            0x20,
            0x03,
            0x02,0x30,
            0x00,0x01};
            Assert.AreEqual(true, ValueEquals(actual, expect), $"actual is: 0x{actual.ToHexLogString()}");
        }

        [TestMethod]
        public void IncomingMessageTest1()
        {
            var raw_prefix = "00 00 00 00" +
                "00 17" +
                "20" +
                "03" +
                "14";
            var raw_data = "11 22 33 44 55 66 77 88 99 00 11 22 33 44 55 66 77 88 99 00";
            var raw_full = raw_prefix + raw_data;
            var parser = new Parser();
            var actual = parser.Deserialize(raw_full.ToBytes()) as IncomingMessage;
            Assert.AreEqual(true, actual != null);
            Assert.AreEqual(true, actual.SlaveAddress == 0x20);
            Assert.AreEqual(true, actual.FunctionCode == FunctionCodeEnum.读多个寄存器);
            Assert.AreEqual(true, actual.InnerDataLength == 0x14);
            Assert.AreEqual(true, ValueEquals(actual.InnerRawData, raw_data.ToBytes()));
        }
    }
}