FCC/Test/Terminals/WayneChina_IcCardReader_SinoChem_Test/StateMachineMessageCutterUnitTest.cs

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

namespace Test_WayneChina_IcCardReader_SinoChem
{
    [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;
            };

            var rawRealCompleteMsg = new byte[] { 1, 2, 3, 4, 0xFA, 5, 0, 8, 1, 2, 3, 4, 5, 6, 7, 8, 0xA0, 0xB0 };
            cutter.Feed(rawRealCompleteMsg);
            Assert.AreEqual(true, onMsgCutCalledTimes == 1);
            Assert.AreEqual(true, ValueEquals(msg, rawRealCompleteMsg.Skip(4)));
        }

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

            var rawRealCompleteMsg = new byte[] { 1, 2, 3, 4, 0xFA, 5, 0, 8, 1, 2, 3, 4, 5, 6, 7, 8, 0xA0, 0xB0 };
            cutter.Feed(rawRealCompleteMsg);
            Assert.AreEqual(true, onMsgCutCalledTimes == 1);
            Assert.AreEqual(true, ValueEquals(msg, rawRealCompleteMsg.Skip(4)));

            // feed again
            cutter.Feed(rawRealCompleteMsg);
            Assert.AreEqual(true, onMsgCutCalledTimes == 2);
            Assert.AreEqual(true, ValueEquals(msg, rawRealCompleteMsg.Skip(4)));
        }

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

            var rawRealCompleteMsg = new byte[] { 1, 2, 3, 4, 0xFA, 0xFA, 5, 0, 8, 1, 2, 3, 4, 5, 6, 7, 8, 0xA0, 0xB0 };
            cutter.Feed(rawRealCompleteMsg);
            Assert.AreEqual(true, onMsgCutCalledTimes == 0);
            Assert.AreEqual(true, msg == null);
        }

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

            var rawRealCompleteMsg = new byte[] { 1, 2, 3, 4, 0xFA, 0xFA, 0xFA, 5, 0, 8, 1, 2, 3, 4, 5, 6, 7, 8, 0xA0, 0xB0 };
            cutter.Feed(rawRealCompleteMsg);
            Assert.AreEqual(true, onMsgCutCalledTimes == 1);
            Assert.AreEqual(true, ValueEquals(msg, rawRealCompleteMsg.Skip(6)));
        }

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

            var rawRealCompleteMsg = new byte[] { 1, 2, 3, 4, 0xFA, 0xFA, 0xFA, 0xFA, 0xFA, 5, 0, 8, 1, 2, 3, 4, 5, 6, 7, 8, 0xA0, 0xB0 };
            cutter.Feed(rawRealCompleteMsg);
            Assert.AreEqual(true, onMsgCutCalledTimes == 1);
            Assert.AreEqual(true, ValueEquals(msg, rawRealCompleteMsg.Skip(8)));
        }

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

            var rawRealCompleteMsg = new byte[] { 1, 2, 3, 4, 0xFA, 0xFA, 0xFA, 0xFA, 0xFA, 5, 0, 9, 0xFA, 0xFA, 2, 3, 4, 5, 6, 7, 8, 9, 0xA0, 0xB0 };
            var validMsg = new byte[] { 0xFA, 5, 0, 9, 0xFA, 2, 3, 4, 5, 6, 7, 8, 9, 0xA0, 0xB0 };

            cutter.Feed(rawRealCompleteMsg);
            Assert.AreEqual(true, onMsgCutCalledTimes == 1);
            Assert.AreEqual(true, ValueEquals(msg, validMsg));
        }

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

            var rawRealCompleteMsg = new byte[] { 1, 2, 3, 4, 0xFA, 0xFA, 0xFA, 0xFA, 0xFA, 5, 0, 9, 0xFA, 0xFA, 0xFA, 0xFA, 3, 4, 5, 6, 7, 8, 9, 0xA0, 0xB0 };
            var validMsg = new byte[] { 0xFA, 5, 0, 9, 0xFA, 0xFA, 3, 4, 5, 6, 7, 8, 9, 0xA0, 0xB0 };

            cutter.Feed(rawRealCompleteMsg);
            Assert.AreEqual(true, onMsgCutCalledTimes == 1);
            Assert.AreEqual(true, ValueEquals(msg, validMsg));
        }

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

            var rawRealCompleteMsg = new byte[] { 1, 2, 3, 4, 0xFA, 0xFA, 0xFA, 0xFA, 0xFA, 5, 0, 9, 0xFA, 0xFA, 0xFA, 0xFA, 0xFA, 0xFA, 4, 5, 6, 7, 8, 9, 0xA0, 0xB0 };
            var validMsg = new byte[] { 0xFA, 5, 0, 9, 0xFA, 0xFA, 0xFA, 4, 5, 6, 7, 8, 9, 0xA0, 0xB0 };

            cutter.Feed(rawRealCompleteMsg);
            Assert.AreEqual(true, onMsgCutCalledTimes == 1);
            Assert.AreEqual(true, ValueEquals(msg, validMsg));
        }

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

            var rawRealCompleteMsg = new byte[] { 1, 2, 3, 4, 0xFA, 0xFA, 0xFA, 0xFA, 0xFA, 5, 0, 9, 0xFA, 0xFA, 0xFA, 0xFA, 0xFA, 0xFA, 4, 5, 0xFA, 0xFA, 7, 8, 9, 0xA0, 0xB0 };
            var validMsg = new byte[] { 0xFA, 5, 0, 9, 0xFA, 0xFA, 0xFA, 4, 5, 0xFA, 7, 8, 9, 0xA0, 0xB0 };

            cutter.Feed(rawRealCompleteMsg);
            Assert.AreEqual(true, onMsgCutCalledTimes == 1);
            Assert.AreEqual(true, ValueEquals(msg, validMsg));
        }

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

            var rawRealCompleteMsg = new byte[] { 1, 2, 3, 4, 0xFA, 0xFA, 0xFA, 0xFA, 0xFA, 5, 0, 8, 2, 3, 4, 5, 6, 7, 8, 0xFA, 0xFA, 0xA0, 0xB0 };
            var validMsg = new byte[] { 0xFA, 5, 0, 8, 2, 3, 4, 5, 6, 7, 8, 0xFA, 0xA0, 0xB0 };

            cutter.Feed(rawRealCompleteMsg);
            Assert.AreEqual(true, onMsgCutCalledTimes == 1);
            Assert.AreEqual(true, ValueEquals(msg, validMsg));
        }

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

            var rawRealCompleteMsg = new byte[] { 0xFA, 5, 0, 8, 0xFA, 0xFA, 3, 4, 5, 6, 7, 8, 0xFA, 0xFA, 0xA0, 0xB0 };
            var validMsg = new byte[] { 0xFA, 5, 0, 8, 0xFA, 3, 4, 5, 6, 7, 8, 0xFA, 0xA0, 0xB0 };

            cutter.Feed(rawRealCompleteMsg);
            Assert.AreEqual(true, onMsgCutCalledTimes == 1);
            Assert.AreEqual(true, ValueEquals(msg, validMsg));
        }

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

            var rawRealCompleteMsg = new byte[] { 0xFA, 5, 0, 8, 0xFA, 0xFA, 3, 4, 0xFA, 0xFA, 6, 7, 8, 0xFA, 0xFA, 0xA0, 0xB0 };
            var validMsg = new byte[] { 0xFA, 5, 0, 8, 0xFA, 3, 4, 0xFA, 6, 7, 8, 0xFA, 0xA0, 0xB0 };

            cutter.Feed(rawRealCompleteMsg);
            Assert.AreEqual(true, onMsgCutCalledTimes == 1);
            Assert.AreEqual(true, ValueEquals(msg, validMsg));
        }

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

            var rawRealCompleteMsg = new byte[] { 0xFA, 5, 0, 1, 0xFA, 0xFA, 0xA0, 0xB0 };
            var validMsg = new byte[] { 0xFA, 5, 0, 1, 0xFA, 0xA0, 0xB0 };

            cutter.Feed(rawRealCompleteMsg);
            Assert.AreEqual(true, onMsgCutCalledTimes == 1);
            Assert.AreEqual(true, ValueEquals(msg, validMsg));
        }

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

            var rawRealCompleteMsg = new byte[] { 0xFA, 5, 0, 2, 0xFA, 0xFA, 0xFA, 0xFA, 0xA0, 0xB0 };
            var validMsg = new byte[] { 0xFA, 5, 0, 2, 0xFA, 0xFA, 0xA0, 0xB0 };

            cutter.Feed(rawRealCompleteMsg);
            Assert.AreEqual(true, onMsgCutCalledTimes == 1);
            Assert.AreEqual(true, ValueEquals(msg, validMsg));
        }

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

            var rawRealCompleteMsg = new byte[] { 0xFA, 5, 0, 2, 3, 4, 0xFA, 0xFA, 0xB0 };
            var validMsg = new byte[] { 0xFA, 5, 0, 2, 3, 4, 0xFA, 0xB0 };

            cutter.Feed(rawRealCompleteMsg);
            Assert.AreEqual(true, onMsgCutCalledTimes == 1);
            Assert.AreEqual(true, ValueEquals(msg, validMsg));
        }

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

            var rawRealCompleteMsg = new byte[] { 0xFA, 5, 0, 2, 3, 4, 0xB0, 0xFA, 0xFA };
            var validMsg = new byte[] { 0xFA, 5, 0, 2, 3, 4, 0xB0, 0xFA };

            cutter.Feed(rawRealCompleteMsg);
            Assert.AreEqual(true, onMsgCutCalledTimes == 1);
            Assert.AreEqual(true, ValueEquals(msg, validMsg));
        }

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

            var rawRealCompleteMsg = new byte[] { 0xFA, 5, 0, 2, 3, 4, 0xFA, 0xFA, 0xFA, 0xFA };
            var validMsg = new byte[] { 0xFA, 5, 0, 2, 3, 4, 0xFA, 0xFA };

            cutter.Feed(rawRealCompleteMsg);
            Assert.AreEqual(true, onMsgCutCalledTimes == 1);
            Assert.AreEqual(true, ValueEquals(msg, validMsg));
        }

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

            var rawRealCompleteMsg = new byte[] { 0xFA, 5, 0, 2, 0xFA, 0xFA, 4, 0xFA, 0xFA, 0xFA, 0xFA };
            var validMsg = new byte[] { 0xFA, 5, 0, 2, 0xFA, 4, 0xFA, 0xFA };

            cutter.Feed(rawRealCompleteMsg);
            Assert.AreEqual(true, onMsgCutCalledTimes == 1);
            Assert.AreEqual(true, ValueEquals(msg, validMsg));
        }

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

            var rawRealCompleteMsg = new byte[] { 11, 22, 33, 0xFA, 5, 0, 2, 0xFA, 0xFA, 0xFA, 0xFA, 0xFA, 0xFA, 0xFA, 0xFA };
            var validMsg = new byte[] { 0xFA, 5, 0, 2, 0xFA, 0xFA, 0xFA, 0xFA };

            cutter.Feed(rawRealCompleteMsg);
            Assert.AreEqual(true, onMsgCutCalledTimes == 1);
            Assert.AreEqual(true, ValueEquals(msg, validMsg));
        }

        [TestMethod]
        public void ShouldCutTest21()
        {
            var cutter = new StateMachineMessageCutter();
            int onMsgCutCalledTimes = 0;
            List<byte[]> msg = new List<byte[]>();
            cutter.OnMessageCut += (s, a) =>
            {
                onMsgCutCalledTimes++;
                msg.Add(cutter.Message);
            };

            var rawRealCompleteMsg = new byte[] { 11, 22, 33, 0xFA, 5, 0, 2, 0xFA, 0xFA, 0xFA, 0xFA, 0xFA, 0xFA, 0xFA, 0xFA,0x00,0x31,
                0xFA,5,0,2,0x11,0x22,0x33,0x44 };
            var validMsg0 = new byte[] { 0xFA, 5, 0, 2, 0xFA, 0xFA, 0xFA, 0xFA };
            var validMsg1 = new byte[] { 0xFA, 5, 0, 2, 0x11, 0x22, 0x33, 0x44 };
            cutter.Feed(rawRealCompleteMsg);
            Assert.AreEqual(true, onMsgCutCalledTimes == 2);
            Assert.AreEqual(true, ValueEquals(msg[0], validMsg0));
            Assert.AreEqual(true, ValueEquals(msg[1], validMsg1));
        }

        [TestMethod]
        public void ShouldCutTest22()
        {
            var cutter = new StateMachineMessageCutter();
            int onMsgCutCalledTimes = 0;
            List<byte[]> msg = new List<byte[]>();
            cutter.OnMessageCut += (s, a) =>
            {
                onMsgCutCalledTimes++;
                msg.Add(cutter.Message);
            };

            var rawRealCompleteMsg = new byte[] { 11, 22, 33, 0xFA, 5, 0, 2, 0xFA, 0xFA, 0xFA, 0xFA, 0xFA, 0xFA, 0xFA, 0xFA,0x00,0x31,
                0xFA,0xFA,5,0,2,0x11,0x22,0x33,0x44 };
            var validMsg0 = new byte[] { 0xFA, 5, 0, 2, 0xFA, 0xFA, 0xFA, 0xFA };
            cutter.Feed(rawRealCompleteMsg);
            Assert.AreEqual(true, onMsgCutCalledTimes == 1);
            Assert.AreEqual(true, ValueEquals(msg[0], validMsg0));
        }

        [TestMethod]
        public void ShouldCutTest23()
        {
            var cutter = new StateMachineMessageCutter();
            int onMsgCutCalledTimes = 0;
            List<byte[]> msg = new List<byte[]>();
            cutter.OnMessageCut += (s, a) =>
            {
                onMsgCutCalledTimes++;
                msg.Add(cutter.Message);
            };

            var rawRealCompleteMsg = new byte[] { 11, 22, 33, 0xFA, 5, 0, 2, 0xFA, 0xFA, 0xFA, 0xFA, 0xFA, 0xFA, 0xFA, 0xFA,0x00,0x31,
                0xFA,0xFA,0xFA,5,0,2,0x11,0x22,0x33,0xFA,0xFA };
            var validMsg0 = new byte[] { 0xFA, 5, 0, 2, 0xFA, 0xFA, 0xFA, 0xFA };
            var validMsg1 = new byte[] { 0xFA, 5, 0, 2, 0x11, 0x22, 0x33, 0xFA };
            cutter.Feed(rawRealCompleteMsg);
            Assert.AreEqual(true, onMsgCutCalledTimes == 2);
            Assert.AreEqual(true, ValueEquals(msg[0], validMsg0));
            Assert.AreEqual(true, ValueEquals(msg[1], validMsg1));
        }

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

            var rawRealCompleteMsg = new byte[] { 11, 22, 33, 0xFA, 5, 0, 2, 0xFA, 0xFA, 0xFA, 0xFA, 0xFA, 0xFA, 0xFA, 0xFA };
            var validMsg = new byte[] { 0xFA, 5, 0, 2, 0xFA, 0xFA, 0xFA, 0xFA };

            cutter.Feed(rawRealCompleteMsg);
            Assert.AreEqual(true, onMsgCutCalledTimes == 1);
            Assert.AreEqual(true, ValueEquals(msg, validMsg));

            rawRealCompleteMsg = new byte[] { 11, 22, 33, 0xFA, 5, 0, 2, 0xFA, 0xFA, 0xFA, 0xFA, 0xFA, 0xFA, 0xFA, 0xFA };
            validMsg = new byte[] { 0xFA, 5, 0, 2, 0xFA, 0xFA, 0xFA, 0xFA };
            cutter.Feed(rawRealCompleteMsg);
            Assert.AreEqual(true, onMsgCutCalledTimes == 2);
            Assert.AreEqual(true, ValueEquals(msg, validMsg));

            rawRealCompleteMsg = new byte[] { 11, 22, 33, 0xFA, 0xFA, 0xFA, 5, 0, 2, 0xFA, 0xFA, 0xFA, 0xFA, 0xFA, 0xFA, 0xFA, 0xFA };
            validMsg = new byte[] { 0xFA, 5, 0, 2, 0xFA, 0xFA, 0xFA, 0xFA };
            cutter.Feed(rawRealCompleteMsg);
            Assert.AreEqual(true, onMsgCutCalledTimes == 3);
            Assert.AreEqual(true, ValueEquals(msg, validMsg));

            rawRealCompleteMsg = new byte[] { 11, 22, 33, 0xFA, 0xFA, 0xFA, 5, 0, 2, 1, 0xFA, 0xFA, 0xFA, 0xFA, 0xFA, 0xFA };
            validMsg = new byte[] { 0xFA, 5, 0, 2, 1, 0xFA, 0xFA, 0xFA };
            cutter.Feed(rawRealCompleteMsg);
            Assert.AreEqual(true, onMsgCutCalledTimes == 4);
            Assert.AreEqual(true, ValueEquals(msg, validMsg));

            rawRealCompleteMsg = new byte[] { 11, 22, 33, 0xFA, 0xFA, 0xFA, 5, 0, 2, 1, 0xFA, 0xFA, 0x11, 0x22 };
            validMsg = new byte[] { 0xFA, 5, 0, 2, 1, 0xFA, 0x11, 0x22 };
            cutter.Feed(rawRealCompleteMsg);
            Assert.AreEqual(true, onMsgCutCalledTimes == 5);
            Assert.AreEqual(true, ValueEquals(msg, validMsg));
        }
    }
}