FCC/Test/Devices/Pumps/Wayne_Pump_Dart_Test/StateMachineMessageCutterUnitTest.cs

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

namespace Wayne_Pump_Dart_Test
{
    [TestClass]
    public class StateMachineMessageCutterUnitTest
    {
        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 StateMachineMessageCutter();
            int onMsgCutCalledTimes = 0;
            byte[] msg = null;
            cutter.OnMessageCut += (s, a) =>
            {
                onMsgCutCalledTimes++;
                msg = cutter.Message;
            };

            string rawRealCompleteMsg = "50 20 FA";
            cutter.Feed(rawRealCompleteMsg.ToBytes());
            Assert.AreEqual(true, onMsgCutCalledTimes == 1);
            Assert.AreEqual(true, ValueEquals(msg, rawRealCompleteMsg.ToBytes()));
        }

        [TestMethod]
        public void ShouldCutTest2()
        {
            StateMachineMessageCutter cutter = new StateMachineMessageCutter();
            int onMsgCutCalledTimes = 0;
            byte[] msg = null;
            cutter.OnMessageCut += (s, a) =>
            {
                onMsgCutCalledTimes++;
                msg = cutter.Message;
            };

            string rawRealCompleteMsg = "50 20 FA";
            string rawRealMsgWithExtraHeaderAndTail = "00 20 02 50 20 FA 00 00 00 00 00";
            cutter.Feed(rawRealMsgWithExtraHeaderAndTail.ToBytes());
            Assert.AreEqual(true, onMsgCutCalledTimes == 1);
            Assert.AreEqual(true, ValueEquals(msg, rawRealCompleteMsg.ToBytes()));
        }

        [TestMethod]
        public void ShouldCutTest3()
        {
            StateMachineMessageCutter cutter = new StateMachineMessageCutter();
            int onMsgCutCalledTimes = 0;
            byte[] msg = null;
            cutter.OnMessageCut += (s, a) =>
            {
                onMsgCutCalledTimes++;
                msg = cutter.Message;
            };

            string rawRealCompleteMsg = "50 20 FA FA";
            string rawRealMsgWithExtraHeaderAndTail = "50 20 10 FA FA";
            cutter.Feed(rawRealMsgWithExtraHeaderAndTail.ToBytes());
            Assert.AreEqual(true, onMsgCutCalledTimes == 1);
            Assert.AreEqual(true, ValueEquals(msg, rawRealCompleteMsg.ToBytes()));
        }

        [TestMethod]
        public void ShouldCutTest3_1()
        {
            StateMachineMessageCutter cutter = new StateMachineMessageCutter();
            int onMsgCutCalledTimes = 0;
            byte[] msg = null;
            cutter.OnMessageCut += (s, a) =>
            {
                onMsgCutCalledTimes++;
                msg = cutter.Message;
            };

            string rawRealCompleteMsg = "50 20 FA FA";
            string rawRealMsgWithExtraHeaderAndTail = "50 20 10 FA FA FA";
            cutter.Feed(rawRealMsgWithExtraHeaderAndTail.ToBytes());
            Assert.AreEqual(true, onMsgCutCalledTimes == 1);
            Assert.AreEqual(true, ValueEquals(msg, rawRealCompleteMsg.ToBytes()));
        }

        [TestMethod]
        public void ShouldCutTest3_2()
        {
            StateMachineMessageCutter cutter = new StateMachineMessageCutter();
            int onMsgCutCalledTimes = 0;
            byte[] msg = null;
            cutter.OnMessageCut += (s, a) =>
            {
                onMsgCutCalledTimes++;
                msg = cutter.Message;
            };

            string rawRealCompleteMsg = "50 20 FA FA FA";
            string rawRealMsgWithExtraHeaderAndTail = "50 20 10 FA 10 FA FA";
            cutter.Feed(rawRealMsgWithExtraHeaderAndTail.ToBytes());
            Assert.AreEqual(true, onMsgCutCalledTimes == 1);
            Assert.AreEqual(true, ValueEquals(msg, rawRealCompleteMsg.ToBytes()));
        }

        [TestMethod]
        public void ShouldCutTest3_3()
        {
            StateMachineMessageCutter cutter = new StateMachineMessageCutter();
            int onMsgCutCalledTimes = 0;
            byte[] msg = null;
            cutter.OnMessageCut += (s, a) =>
            {
                onMsgCutCalledTimes++;
                msg = cutter.Message;
            };

            string rawRealCompleteMsg = "50 20 FA FA 33 FA";
            string rawRealMsgWithExtraHeaderAndTail = "50 20 10 FA 10 FA 33 FA 44";
            cutter.Feed(rawRealMsgWithExtraHeaderAndTail.ToBytes());
            Assert.AreEqual(true, onMsgCutCalledTimes == 1);
            Assert.AreEqual(true, ValueEquals(msg, rawRealCompleteMsg.ToBytes()));
        }


        [TestMethod]
        public void ShouldCutTest4()
        {
            StateMachineMessageCutter cutter = new StateMachineMessageCutter();
            int onMsgCutCalledTimes = 0;
            byte[] msg = null;
            cutter.OnMessageCut += (s, a) =>
            {
                onMsgCutCalledTimes++;
                msg = cutter.Message;
            };

            string rawRealCompleteMsg = "50 20 FA";
            string rawRealMsgWithExtraHeaderAndTail = "50 20 FA 50 20 FA";
            cutter.Feed(rawRealMsgWithExtraHeaderAndTail.ToBytes());
            Assert.AreEqual(true, onMsgCutCalledTimes == 2);
            Assert.AreEqual(true, ValueEquals(msg, rawRealCompleteMsg.ToBytes()));
        }

        [TestMethod]
        public void ShouldCutTest4_1()
        {
            StateMachineMessageCutter cutter = new StateMachineMessageCutter();
            int onMsgCutCalledTimes = 0;
            byte[] msg = null;
            string rawRealCompleteMsg = "50 20 FA";
            cutter.OnMessageCut += (s, a) =>
            {
                onMsgCutCalledTimes++;
                msg = cutter.Message;
                Assert.AreEqual(true, ValueEquals(msg, rawRealCompleteMsg.ToBytes()));
            };
            string rawRealMsgWithExtraHeaderAndTail = "50 20 FA 22 50 20 FA 22 50 20 FA 22 50 20 FA";
            cutter.Feed(rawRealMsgWithExtraHeaderAndTail.ToBytes());
            Assert.AreEqual(true, onMsgCutCalledTimes == 4);
            Assert.AreEqual(true, ValueEquals(msg, rawRealCompleteMsg.ToBytes()));
        }

        [TestMethod]
        public void ShouldCutTest4_2()
        {
            StateMachineMessageCutter cutter = new StateMachineMessageCutter();
            int onMsgCutCalledTimes = 0;
            byte[] msg = null;
            string rawRealCompleteMsg = "50 20 50 20 FA";
            cutter.OnMessageCut += (s, a) =>
            {
                onMsgCutCalledTimes++;
                msg = cutter.Message;
                Assert.AreEqual(true, ValueEquals(msg, rawRealCompleteMsg.ToBytes()));
            };
            string rawRealMsgWithExtraHeaderAndTail = "50 20 50 20 FA " +
                "22 50 20 50 20 FA " +
                "22 50 20 50 20 FA " +
                "22 50 20 50 20 FA" +
                "22 50 20 50 20 FA";
            cutter.Feed(rawRealMsgWithExtraHeaderAndTail.ToBytes());
            Assert.AreEqual(true, onMsgCutCalledTimes == 5);
            Assert.AreEqual(true, ValueEquals(msg, rawRealCompleteMsg.ToBytes()));
        }

        [TestMethod]
        public void ShouldCutTest4_3()
        {
            StateMachineMessageCutter cutter = new StateMachineMessageCutter();
            int onMsgCutCalledTimes = 0;
            byte[] msg = null;
            string rawRealCompleteMsg = "51 39 02 08 00 00 03 97 00 00 30 64 03 04 00 07 72 00 01 01 3F 3F 05 FA E3 51 39 02 08 00 00 03 97 00 00 30 64 03 04 00 07 72 00 01 01 05 FA E3 03 FA";
            cutter.OnMessageCut += (s, a) =>
            {
                onMsgCutCalledTimes++;
                msg = cutter.Message;
                Assert.AreEqual(true, ValueEquals(msg, rawRealCompleteMsg.ToBytes()));
            };
            string rawRealMsgWithExtraHeaderAndTail = "51 39 02 08 00 00 03 97 00 00 30 64 03 04 00 07 72 00 01 01 3F 3F 05 FA E3 51 39 02 08 00 00 03 97 00 00 30 64 03 04 00 07 72 00 01 01 05 FA E3 03 FA";
            cutter.Feed(rawRealMsgWithExtraHeaderAndTail.ToBytes());
            Assert.AreEqual(true, onMsgCutCalledTimes == 5);
            Assert.AreEqual(true, ValueEquals(msg, rawRealCompleteMsg.ToBytes()));
        }

        [TestMethod]
        public void ShouldCutTest4_4()
        {
            StateMachineMessageCutter cutter = new StateMachineMessageCutter();
            int onMsgCutCalledTimes = 0;
            List<byte[]> messagesCut = null;
            string rawRealCompleteMsg = "53 20 FA 53 70 FA";
            cutter.OnMessageCut += (s, a) =>
            {
                onMsgCutCalledTimes++;
                messagesCut.Add(cutter.Message);
            };
            cutter.Feed(rawRealCompleteMsg.ToBytes());
            Assert.AreEqual(true, onMsgCutCalledTimes == 2);
            Assert.AreEqual(true, ValueEquals(messagesCut[0], "53 20 FA".ToBytes()));
            Assert.AreEqual(true, ValueEquals(messagesCut[1], "53 70 FA".ToBytes()));
        }
    }
}