using FuRen_Sinopec_IcCardReader;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using Edge.Core.Parser.BinaryParser.Util;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace MessageParserTest
{
    [TestClass()]
    public class InnerStateMachineTests
    {
        [TestMethod()]
        public void FeedTest1()
        {
            var source = new List<byte>() { 1, 2, 3, 4, 0xFA, 5, 6, 7, 0, 8, 1, 2, 3, 4, 5, 6, 7, 8, 0xA0, 0xB0 };
            List<byte> result = null;

            //ComPortProcessor.
            var stateMachine = new StateMachineMessageCutter();
            stateMachine.OnMessageCut += (r, _) =>
            {
                result = stateMachine.Message.ToList();
            };
            bool invalidMessageCutCalled = false;
            stateMachine.OnInvalidMessageRead += (__, ___) => invalidMessageCutCalled = true;
            stateMachine.Feed(source.ToArray());

            Assert.AreEqual(true, result != null);
            Assert.AreEqual(true, invalidMessageCutCalled != true);
            Assert.AreEqual(true, result.Any());
            Assert.AreEqual(true, result[0] == 0xFA);
            Assert.AreEqual(true, ((new List<byte>() { result[4], result[5] }).ToArray()).GetBCD() == 8);
            Assert.AreEqual(true, result.Count == 16);
            Assert.AreEqual(true, result.Last() == 0xB0);
        }

        [TestMethod()]
        public void FeedTest2()
        {
            var source = new List<byte>() { 1, 2, 3, 4, 0xFA, 5, 6, 7, 0, 8, 1, 2, 3, 4, 5, 6, 7, 8, 0xA0, 0xB0 };
            List<byte> result = null;
            var stateMachine = new StateMachineMessageCutter();
            stateMachine.OnMessageCut += (r, _) =>
            {
                result = stateMachine.Message.ToList();
            };
            bool invalidMessageCutCalled = false;
            stateMachine.OnInvalidMessageRead += (__, ___) => invalidMessageCutCalled = true;
            stateMachine.Feed(source.ToArray());
            //}

            Assert.AreEqual(true, result != null);
            Assert.AreEqual(true, invalidMessageCutCalled != true);
            Assert.AreEqual(true, result.Any());
            Assert.AreEqual(true, result[0] == 0xFA);
            Assert.AreEqual(true, ((new List<byte>() { result[4], result[5] }).ToArray()).GetBCD() == 8);
            Assert.AreEqual(true, result.Count == 16);
            Assert.AreEqual(true, result.Last() == 0xB0);

            result = null;
            stateMachine.Feed(source.ToArray());

            Assert.AreEqual(true, result != null);
            Assert.AreEqual(true, invalidMessageCutCalled != true);
            Assert.AreEqual(true, result.Any());
            Assert.AreEqual(true, result[0] == 0xFA);
            Assert.AreEqual(true, ((new List<byte>() { result[4], result[5] }).ToArray()).GetBCD() == 8);
            Assert.AreEqual(true, result.Count == 16);
            Assert.AreEqual(true, result.Last() == 0xB0);
        }

        [TestMethod()]
        public void FeedTest3()
        {
            var source = new List<byte>() { 1, 2, 3, 4, 0xFA, 0xFA, 5, 6, 7, 0, 8, 1, 2, 3, 4, 5, 6, 7, 8, 0xA0, 0xB0 };
            List<byte> result = null;
            var stateMachine = new StateMachineMessageCutter();
            stateMachine.OnMessageCut += (r, _) =>
            {
                result = stateMachine.Message.ToList();
            };
            bool invalidMessageCutCalled = false;
            stateMachine.OnInvalidMessageRead += (__, ___) => invalidMessageCutCalled = true;
            stateMachine.Feed(source.ToArray());
            //}
            Assert.AreEqual(true, invalidMessageCutCalled != true);
            Assert.AreEqual(true, result == null);
        }

        [TestMethod()]
        public void FeedTest4()
        {
            var source = new List<byte>() { 1, 2, 3, 4, 0xFA, 0xFA, 0xFA, 5, 6, 7, 0, 8, 1, 2, 3, 4, 5, 6, 7, 8, 0xA0, 0xB0 };
            List<byte> result = null;
            var stateMachine = new StateMachineMessageCutter();
            stateMachine.OnMessageCut += (r, _) =>
            {
                result = stateMachine.Message.ToList();
            };
            bool invalidMessageCutCalled = false;
            stateMachine.OnInvalidMessageRead += (__, ___) => invalidMessageCutCalled = true;
            stateMachine.Feed(source.ToArray());
            //}

            Assert.AreEqual(true, result != null);
            Assert.AreEqual(true, invalidMessageCutCalled != true);
            Assert.AreEqual(true, result.Any());
            Assert.AreEqual(true, result[0] == 0xFA);
            Assert.AreEqual(true, ((new List<byte>() { result[4], result[5] }).ToArray()).GetBCD() == 8);
            Assert.AreEqual(true, result.Count == 16);
            Assert.AreEqual(true, result.Last() == 0xB0);
        }

        [TestMethod()]
        public void FeedTest5()
        {
            var source = new List<byte>() { 1, 2, 3, 4, 0xFA, 0xFA, 0xFA, 0xFA, 0xFA, 5, 6, 7, 0, 9, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0xA0, 0xB0 };
            List<byte> result = null;
            var stateMachine = new StateMachineMessageCutter();
            stateMachine.OnMessageCut += (r, _) =>
            {
                result = stateMachine.Message.ToList();
            };
            bool invalidMessageCutCalled = false;
            stateMachine.OnInvalidMessageRead += (__, ___) => invalidMessageCutCalled = true;
            stateMachine.Feed(source.ToArray());
            //}

            Assert.AreEqual(true, result != null);
            Assert.AreEqual(true, invalidMessageCutCalled != true);
            Assert.AreEqual(true, result.Any());
            Assert.AreEqual(true, result[0] == 0xFA);
            Assert.AreEqual(true, ((new List<byte>() { result[4], result[5] }).ToArray()).GetBCD() == 9);
            Assert.AreEqual(true, result.Count == 17);
            Assert.AreEqual(true, result.Last() == 0xB0);
        }

        [TestMethod()]
        public void FeedTest6()
        {
            var source = new List<byte>() { 1, 2, 3, 4, 0xFA, 0xFA, 0xFA, 0xFA, 0xFA, 5, 6, 7, 0, 9, 0xFA, 0xFA, 2, 3, 4, 5, 6, 7, 8, 9, 0xA0, 0xB0 };
            List<byte> result = null;
            var stateMachine = new StateMachineMessageCutter();
            stateMachine.OnMessageCut += (r, _) =>
            {
                result = stateMachine.Message.ToList();
            };
            bool invalidMessageCutCalled = false;
            stateMachine.OnInvalidMessageRead += (__, ___) => invalidMessageCutCalled = true;
            stateMachine.Feed(source.ToArray());
            //}

            Assert.AreEqual(true, result != null);
            Assert.AreEqual(true, invalidMessageCutCalled != true);
            Assert.AreEqual(true, result.Any());
            Assert.AreEqual(true, result[0] == 0xFA);
            Assert.AreEqual(true, ((new List<byte>() { result[4], result[5] }).ToArray()).GetBCD() == 9);
            Assert.AreEqual(true, result.Count == 17);
            Assert.AreEqual(true, result[6] == 0xFA);
            Assert.AreEqual(true, result[7] == 2);
            Assert.AreEqual(true, result.Last() == 0xB0);
        }

        [TestMethod()]
        public void FeedTest7()
        {
            var source = new List<byte>() { 1, 2, 3, 4, 0xFA, 0xFA, 0xFA, 0xFA, 0xFA, 5, 6, 7, 0, 9, 0xFA, 0xFA, 2, 3, 4, 5, 6, 7, 8, 0xFA, 0xFA, 0xA0, 0xB0 };
            List<byte> result = null;
            var stateMachine = new StateMachineMessageCutter();
            stateMachine.OnMessageCut += (r, _) =>
            {
                result = stateMachine.Message.ToList();
            };
            bool invalidMessageCutCalled = false;
            stateMachine.OnInvalidMessageRead += (__, ___) => invalidMessageCutCalled = true;
            stateMachine.Feed(source.ToArray());
            //}

            Assert.AreEqual(true, result != null);
            Assert.AreEqual(true, invalidMessageCutCalled != true);
            Assert.AreEqual(true, result.Any());
            Assert.AreEqual(true, result[0] == 0xFA);
            Assert.AreEqual(true, ((new List<byte>() { result[4], result[5] }).ToArray()).GetBCD() == 9);
            Assert.AreEqual(true, result.Count == 17);
            Assert.AreEqual(true, result[6] == 0xFA);
            Assert.AreEqual(true, result[7] == 2);
            Assert.AreEqual(true, result[14] == 0xFA);
            Assert.AreEqual(true, result[15] == 0xA0);
            Assert.AreEqual(true, result.Last() == 0xB0);
        }

        [TestMethod()]
        public void FeedTest8()
        {
            var source = new List<byte>() { 1, 2, 3, 4, 0xFA, 0xFA, 0xFA, 0xFA, 0xFA, 5, 6, 7, 0, 9, 0xFA, 0xFA, 0xFA, 0xFA, 3, 4, 5, 6, 7, 8, 0xFA, 0xFA, 0xA0, 0xB0 };
            List<byte> result = null;
            var stateMachine = new StateMachineMessageCutter();
            stateMachine.OnMessageCut += (r, _) =>
            {
                result = stateMachine.Message.ToList();
            };
            bool invalidMessageCutCalled = false;
            stateMachine.OnInvalidMessageRead += (__, ___) => invalidMessageCutCalled = true;
            stateMachine.Feed(source.ToArray());
            //}

            Assert.AreEqual(true, result != null);
            Assert.AreEqual(true, invalidMessageCutCalled != true);
            Assert.AreEqual(true, result.Any());
            Assert.AreEqual(true, result[0] == 0xFA);
            Assert.AreEqual(true, ((new List<byte>() { result[4], result[5] }).ToArray()).GetBCD() == 9);
            Assert.AreEqual(true, result.Count == 17);
            Assert.AreEqual(true, result[6] == 0xFA);
            Assert.AreEqual(true, result[7] == 0xFA);
            Assert.AreEqual(true, result[8] == 3);
            Assert.AreEqual(true, result[14] == 0xFA);
            Assert.AreEqual(true, result[15] == 0xA0);
            Assert.AreEqual(true, result.Last() == 0xB0);

            result = null;
            stateMachine.Feed(source.ToArray());

            Assert.AreEqual(true, result != null);
            Assert.AreEqual(true, invalidMessageCutCalled != true);
            Assert.AreEqual(true, result.Any());
            Assert.AreEqual(true, result[0] == 0xFA);
            Assert.AreEqual(true, ((new List<byte>() { result[4], result[5] }).ToArray()).GetBCD() == 9);
            Assert.AreEqual(true, result.Count == 17);
            Assert.AreEqual(true, result[6] == 0xFA);
            Assert.AreEqual(true, result[7] == 0xFA);
            Assert.AreEqual(true, result[8] == 3);
            Assert.AreEqual(true, result[14] == 0xFA);
            Assert.AreEqual(true, result[15] == 0xA0);
            Assert.AreEqual(true, result.Last() == 0xB0);

            result = null;
            stateMachine.Feed(source.ToArray());

            Assert.AreEqual(true, result != null);
            Assert.AreEqual(true, invalidMessageCutCalled != true);
            Assert.AreEqual(true, result.Any());
            Assert.AreEqual(true, result[0] == 0xFA);
            Assert.AreEqual(true, ((new List<byte>() { result[4], result[5] }).ToArray()).GetBCD() == 9);
            Assert.AreEqual(true, result.Count == 17);
            Assert.AreEqual(true, result[6] == 0xFA);
            Assert.AreEqual(true, result[7] == 0xFA);
            Assert.AreEqual(true, result[8] == 3);
            Assert.AreEqual(true, result[14] == 0xFA);
            Assert.AreEqual(true, result[15] == 0xA0);
            Assert.AreEqual(true, result.Last() == 0xB0);
        }

        [TestMethod()]
        public void FeedTest9()
        {
            var source = new List<byte>() { 1, 2, 3, 4, 0xFA, 0xFA, 0xFA, 0xFA, 0xFA, 5, 6, 7, 0, 9, 0xFA, 0xFA, 2, 3, 4, 5, 6, 7, 8, 0xFA, 0xFA, 0xFA, 0xFA, 0xB0 };
            List<byte> result = null;
            var stateMachine = new StateMachineMessageCutter();
            stateMachine.OnMessageCut += (r, _) =>
            {
                result = stateMachine.Message.ToList();
            };
            bool invalidMessageCutCalled = false;
            stateMachine.OnInvalidMessageRead += (__, ___) => invalidMessageCutCalled = true;
            stateMachine.Feed(source.ToArray());
            //}

            Assert.AreEqual(true, result != null);
            Assert.AreEqual(true, invalidMessageCutCalled != true);
            Assert.AreEqual(true, result.Any());
            Assert.AreEqual(true, result[0] == 0xFA);
            Assert.AreEqual(true, ((new List<byte>() { result[4], result[5] }).ToArray()).GetBCD() == 9);
            Assert.AreEqual(true, result.Count == 17);
            Assert.AreEqual(true, result[6] == 0xFA);
            Assert.AreEqual(true, result[7] == 2);
            Assert.AreEqual(true, result[14] == 0xFA);
            Assert.AreEqual(true, result[15] == 0xFA);
            Assert.AreEqual(true, result.Last() == 0xB0);
        }

        [TestMethod()]
        public void FeedTest10()
        {
            var source = new List<byte>() { 1, 2, 3, 4, 0xFA, 0xFA, 0xFA, 0xFA, 0xFA, 5, 6, 7, 0, 9, 0xFA, 0xFA, 2, 3, 4, 5, 6, 7, 8, 0xFA, 0xFA, 0x00, 0xFA, 0xFA };
            List<byte> result = null;
            var stateMachine = new StateMachineMessageCutter();
            stateMachine.OnMessageCut += (r, _) =>
            {
                result = stateMachine.Message.ToList();
            };
            bool invalidMessageCutCalled = false;
            stateMachine.OnInvalidMessageRead += (__, ___) => invalidMessageCutCalled = true;
            stateMachine.Feed(source.ToArray());
            //}

            Assert.AreEqual(true, result != null);
            Assert.AreEqual(true, invalidMessageCutCalled != true);
            Assert.AreEqual(true, result.Any());
            Assert.AreEqual(true, result[0] == 0xFA);
            Assert.AreEqual(true, ((new List<byte>() { result[4], result[5] }).ToArray()).GetBCD() == 9);
            Assert.AreEqual(true, result.Count == 17);
            Assert.AreEqual(true, result[6] == 0xFA);
            Assert.AreEqual(true, result[7] == 2);
            Assert.AreEqual(true, result[14] == 0xFA);
            Assert.AreEqual(true, result[15] == 0x00);
            Assert.AreEqual(true, result.Last() == 0xFA);
        }

        [TestMethod()]
        public void FeedTest11()
        {
            var source = new List<byte>() { 1, 2, 3, 4, 0xFA, 0xFA, 0xFA, 0xFA, 0xFA, 5, 6, 7, 0, 9, 0xFA, 0xFA, 2, 3, 4, 5, 6, 7, 8, 0xFA, 0xFA, 0xFA, 0xFA, 0xFA, 0xFA };
            List<byte> result = null;
            var stateMachine = new StateMachineMessageCutter();
            stateMachine.OnMessageCut += (r, _) =>
            {
                result = stateMachine.Message.ToList();
            };
            bool invalidMessageCutCalled = false;
            stateMachine.OnInvalidMessageRead += (__, ___) => invalidMessageCutCalled = true;
            stateMachine.Feed(source.ToArray());
            //}

            Assert.AreEqual(true, result != null);
            Assert.AreEqual(true, invalidMessageCutCalled != true);
            Assert.AreEqual(true, result.Any());
            Assert.AreEqual(true, result[0] == 0xFA);
            Assert.AreEqual(true, ((new List<byte>() { result[4], result[5] }).ToArray()).GetBCD() == 9);
            Assert.AreEqual(true, result.Count == 17);
            Assert.AreEqual(true, result[6] == 0xFA);
            Assert.AreEqual(true, result[7] == 2);
            Assert.AreEqual(true, result[14] == 0xFA);
            Assert.AreEqual(true, result[15] == 0xFA);
            Assert.AreEqual(true, result.Last() == 0xFA);
        }


        [TestMethod()]
        public void FeedTest12()
        {
            var source = new List<byte>() {  11,22, 0xFA,0xFA,
                0xFA, 5, 6, 7, 0, 8, 1, 2, 3, 4, 5, 6, 7,8, 0xFA, 0xFA,0x02, };
            List<byte> result = null;
            var stateMachine = new StateMachineMessageCutter();
            stateMachine.OnMessageCut += (r, _) =>
            {
                result = stateMachine.Message.ToList();
            };
            bool invalidMessageCutCalled = false;
            stateMachine.OnInvalidMessageRead += (__, ___) => invalidMessageCutCalled = true;
            stateMachine.Feed(source.ToArray());
            //}

            Assert.AreEqual(true, result != null);
            Assert.AreEqual(true, invalidMessageCutCalled != true);
            Assert.AreEqual(true, result.Any());
            Assert.AreEqual(true, result[0] == 0xFA);
            Assert.AreEqual(true, ((new List<byte>() { result[4], result[5] }).ToArray()).GetBCD() == 8);
            Assert.AreEqual(true, result.Count == 16);
        }

        [TestMethod()]
        public void FeedTest15()
        {
            var source = new List<byte>() { 1, 2, 3, 4, 0xFA, 0xFA, 0xFA, 0xFA,
                0xFA, 5, 6, 7, 0, 9, 0xFA, 0xFA, 2, 3, 4, 5, 6, 7, 8, 0xFA, 0xFA, 0xFA, 0xFA, 0xFA, 0xFA,
                    11,22,
                0xFA, 5, 6, 7, 0, 9, 0xFA, 0xFA, 2, 3, 4, 5, 6, 7, 8, 0xFA, 0xFA, 0xFA, 0xFA, 0xFA, 0xFA,
                    55,66,
                0xFA, 5, 6, 7, 0, 9, 0xFA, 0xFA, 2, 3, 4, 5, 6, 7, 8, 0xFA, 0xFA, 0xFA, 0xFA, 0xFA, 0xFA,
                    99,88,77,66,};
            List<List<byte>> results = new List<List<byte>>();
            var stateMachine = new StateMachineMessageCutter();
            stateMachine.OnMessageCut += (r, _) =>
            {
                results.Add(stateMachine.Message.ToList());
            };
            bool invalidMessageCutCalled = false;
            stateMachine.OnInvalidMessageRead += (__, ___) => invalidMessageCutCalled = true;
            stateMachine.Feed(source.ToArray());
            //}

            Assert.AreEqual(true, results.Count == 3);
            foreach (var result in results)
            {
                Assert.AreEqual(true, result != null);
                Assert.AreEqual(true, invalidMessageCutCalled != true);
                Assert.AreEqual(true, result.Any());
                Assert.AreEqual(true, result[0] == 0xFA);
                Assert.AreEqual(true, ((new List<byte>() { result[4], result[5] }).ToArray()).GetBCD() == 9);
                Assert.AreEqual(true, result.Count == 17);
                Assert.AreEqual(true, result[6] == 0xFA);
                Assert.AreEqual(true, result[7] == 2);
                Assert.AreEqual(true, result[14] == 0xFA);
                Assert.AreEqual(true, result[15] == 0xFA);
                Assert.AreEqual(true, result.Last() == 0xFA);
            }
        }


        [TestMethod()]
        public void FeedTest30()
        {
            var source = new List<byte>() { 1, 2, 3, 4,
                0xFA, 5, 6, 7, 0, 9, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0x0A, 0x0A,
                0xFA, 5, 6, 7, 0, 8, 1, 2, 3, 4, 5, 6, 7, 8, 0x0A, 0x0A,
                0xFA, 5, 6, 7, 0, 7, 1, 2, 3, 4, 5, 6, 7, 0x0A, 0x0A,
                6,7,8,9, 0xFA, 0xFA,
                0xFA, 5, 6, 7, 0, 7, 1, 2, 3, 4, 5, 6, 7, 0x0A, 0xFA,0xFA,
                0xFA, 5, 6, 7, 0, 9, 0xFA, 0xFA, 2, 3, 4, 5, 6, 7, 8, 0xFA, 0xFA, 0xFA, 0xFA, 0xFA, 0xFA,
                11,22, 0xFA,0xFA,
                0xFA, 5, 6, 7, 0, 8, 1, 2, 3, 4, 5, 6, 7,8, 0xFA, 0xFA,0x02,
                0xFA, 5, 6, 7, 0, 6, 0xFA, 0xFA, 2, 3, 4, 5, 0xFA, 0xFA, 0xFA, 0xFA, 0xFA, 0xFA,
                55,66,
                0xFA, 5, 6, 7, 0, 9, 0xFA, 0xFA, 2, 3, 4, 5, 6, 7, 8, 0xFA, 0xFA, 0xFA, 0xFA, 0xFA, 0xFA,
                99,88,77,66,};
            List<List<byte>> results = new List<List<byte>>();
            var stateMachine = new StateMachineMessageCutter();
            stateMachine.OnMessageCut += (r, _) =>
            {
                results.Add(stateMachine.Message.ToList());
            };
            bool invalidMessageCutCalled = false;
            stateMachine.OnInvalidMessageRead += (__, ___) => invalidMessageCutCalled = true;
            stateMachine.Feed(source.ToArray());

            Assert.AreEqual(true, results.Count == 8, "but actual is " + results.Count);
            foreach (var result in results)
            {
                Assert.AreEqual(true, result != null);
                Assert.AreEqual(true, invalidMessageCutCalled != true);
                Assert.AreEqual(true, result.Any());
                Assert.AreEqual(true, result[0] == 0xFA);
                Assert.AreEqual(true, result[1] != 0xFA);
                Assert.AreEqual(true, ((new List<byte>() { result[4], result[5] }).ToArray()).GetBCD() == (result.Count - 6 - 2));
            }
        }

        [TestMethod()]
        public void FeedTest33()
        {
            var source = new List<byte>() { 1, 2, 3, 4,
                0xFA, 5, 6, 7, 0, 9, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0x0A, 0x0A,
                //crc invalid case 1
                0xFA, 5, 6, 7, 0, 10, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 0xFA, 0x0D,0x11,
                0xFA, 5, 6, 7, 0, 7, 1, 2, 3, 4, 5, 6, 7, 0x0A, 0x0A,
                6,7,8,9, 0xFA, 0xFA,
                //crc invalid case 2
                0xFA, 5, 6, 7, 0, 7, 1, 2, 3, 4, 5, 6, 7, 0xFA,0xFA, 0xFA,0x0B,
                0xFA, 5, 6, 7, 0, 9, 0xFA, 0xFA, 2, 3, 4, 5, 6, 7, 8, 0xFA, 0xFA, 0xFA, 0xFA, 0xFA, 0xFA,
                11,22, 0xFA,0xFA,
                0xFA, 5, 6, 7, 0, 8, 1, 2, 3, 4, 5, 6, 7,8, 0xFA, 0xFA,0x02,
                0xFA, 5, 6, 7, 0, 6, 0xFA, 0xFA, 2, 3, 4, 5, 0xFA, 0xFA, 0xFA, 0xFA, 0xFA, 0xFA,
                55,66,
                0xFA, 5, 6, 7, 0, 9, 0xFA, 0xFA, 2, 3, 4, 5, 6, 7, 8, 0xFA, 0xFA, 0xFA, 0xFA, 0xFA, 0xFA,
                99,88,77,66,};
            List<List<byte>> results = new List<List<byte>>();
            var stateMachine = new StateMachineMessageCutter();
            stateMachine.OnMessageCut += (r, _) =>
            {
                results.Add(stateMachine.Message.ToList());
            };
            int invalidMessageCutCalledTimes = 0;
            stateMachine.OnInvalidMessageRead += (__, ___) => invalidMessageCutCalledTimes++;
            stateMachine.Feed(source.ToArray());

            Assert.AreEqual(true, results.Count == 6, "but actual is " + results.Count);
            Assert.AreEqual(true, invalidMessageCutCalledTimes == 2);
            foreach (var result in results)
            {
                Assert.AreEqual(true, result != null);

                Assert.AreEqual(true, result.Any());
                Assert.AreEqual(true, result[0] == 0xFA);
                Assert.AreEqual(true, result[1] != 0xFA);
                Assert.AreEqual(true, ((new List<byte>() { result[4], result[5] }).ToArray()).GetBCD() == (result.Count - 6 - 2));
            }
        }

        [TestMethod()]
        public void Reduce0xFAPair_Test0()
        {
            var stateMachine = new StateMachineMessageCutter();
            var source = new List<byte>() { 0xFA, 0xFA, 3 };
            stateMachine.Reduce0xFAPair(source, 0);
            Assert.AreEqual(true, source.Count == 2);
            Assert.AreEqual(true, source[0] == 0xFA);
            Assert.AreEqual(true, source[1] == 3);
        }


        [TestMethod()]
        public void Reduce0xFAPair_Test1()
        {
            var stateMachine = new StateMachineMessageCutter();
            var source = new List<byte>() { 0xFA, 0xFA, 0xFA, 0xFA, 3, 4, 5, 6, 7, 8, 0xFA, 0xFA, 0xA0, 0xB0 };
            stateMachine.Reduce0xFAPair(source, 0);
            Assert.AreEqual(true, source.Count == 11);
            Assert.AreEqual(true, source[0] == 0xFA);
            Assert.AreEqual(true, source[1] == 0xFA);
            Assert.AreEqual(true, source[2] == 3);
        }

        [TestMethod()]
        public void Reduce0xFAPair_Test2()
        {
            var stateMachine = new StateMachineMessageCutter();
            var source = new List<byte>() { 0xFA, 0xFA, 0xFA, 0xFA, 2, 3, 4, 5, 6, 7, 0xFA, 0xFA, 0xA0, 0xB0 };
            stateMachine.Reduce0xFAPair(source, 2);
            Assert.AreEqual(true, source.Count == 12);
            Assert.AreEqual(true, source[0] == 0xFA);
            Assert.AreEqual(true, source[1] == 0xFA);
            Assert.AreEqual(true, source[2] == 0xFA);
            Assert.AreEqual(true, source[3] == 2);
        }

        [TestMethod()]
        public void Reduce0xFAPair_Test3()
        {
            var stateMachine = new StateMachineMessageCutter();
            var source = new List<byte>() { 0xFA, 0xFA, 0xFA, 3, 4, 5, 6, 7, 0xFA, 0xFA, 0xA0, 0xB0 };
            stateMachine.Reduce0xFAPair(source, 0);
            Assert.AreEqual(true, source.Count == 10);
            Assert.AreEqual(true, source[0] == 0xFA);
            Assert.AreEqual(true, source[1] == 0xFA);
            Assert.AreEqual(true, source[2] == 3);
            Assert.AreEqual(true, source[3] == 4);
        }

         [TestMethod()]
        public void Reduce0xFAPair_Test3_0()
        {
            var stateMachine = new StateMachineMessageCutter();
            var source = new List<byte>() { 0xFA, 5, 6, 7, 0, 9, 0xFA, 0xFA, 0xFA, 0xFA, 3, 4, 5, 6, 7, 8, 0xFA, 0xFA, 0xA0, 0xB0 };
            stateMachine.Reduce0xFAPair(source, 0);
            Assert.AreEqual(true, source.Count == 17);
            Assert.AreEqual(true, source[0] == 0xFA);
            Assert.AreEqual(true, source[1] == 5);
            Assert.AreEqual(true, source[6] == 0xFA);
            Assert.AreEqual(true, source[7] == 0xFA);
            Assert.AreEqual(true, source[8] == 3);

            Assert.AreEqual(true, source[16] == 0xB0);
            Assert.AreEqual(true, source[15] == 0xA0);
            Assert.AreEqual(true, source[14] == 0xFA);
            Assert.AreEqual(true, source[13] == 8);
        }

        [TestMethod()]
        public void Reduce0xFAPair_Test4()
        {
            var stateMachine = new StateMachineMessageCutter();
            var source = new List<byte>() { 0xFA, 0xFA, 0xFA, 4, 5, 6, 7, 0xFA, 0xFA, 0xA0, 0xB0 };
            stateMachine.Reduce0xFAPair(source, 2);
            Assert.AreEqual(true, source.Count == 10);
            Assert.AreEqual(true, source[0] == 0xFA);
            Assert.AreEqual(true, source[1] == 0xFA);
            Assert.AreEqual(true, source[2] == 0xFA);
            Assert.AreEqual(true, source[3] == 4);

            Assert.AreEqual(true, source[9] == 0xB0);
            Assert.AreEqual(true, source[8] == 0xA0);
            Assert.AreEqual(true, source[7] == 0xFA);
        }

        [TestMethod()]
        public void Reduce0xFAPair_Test5()
        {
            var stateMachine = new StateMachineMessageCutter();
            var source = new List<byte>() { 0xFA, 0xFA, 0xFA, 4, 5, 6, 7, 0xFA, 0xFA, 0xFA, 0xFA };
            stateMachine.Reduce0xFAPair(source, 2);
            Assert.AreEqual(true, source.Count == 9);
            Assert.AreEqual(true, source[0] == 0xFA);
            Assert.AreEqual(true, source[1] == 0xFA);
            Assert.AreEqual(true, source[2] == 0xFA);
            Assert.AreEqual(true, source[3] == 4);
            Assert.AreEqual(true, source[6] == 7);
            Assert.AreEqual(true, source[7] == 0xFA);
            Assert.AreEqual(true, source[8] == 0xFA);
        }

        [TestMethod()]
        public void Reduce0xFAPair_Test6()
        {
            var stateMachine = new StateMachineMessageCutter();
            var source = new List<byte>() { 0xFA, 0xFA, 0xFA, 4, 5, 6, 7, 0xFA, 0xFA };
            stateMachine.Reduce0xFAPair(source, 2);
            Assert.AreEqual(true, source.Count == 8);
            Assert.AreEqual(true, source[0] == 0xFA);
            Assert.AreEqual(true, source[1] == 0xFA);
            Assert.AreEqual(true, source[2] == 0xFA);
            Assert.AreEqual(true, source[3] == 4);
            Assert.AreEqual(true, source[6] == 7);
            Assert.AreEqual(true, source[7] == 0xFA);
        }

        [TestMethod()]
        public void Reduce0xFAPair_Test7()
        {
            var stateMachine = new StateMachineMessageCutter();
            var source = new List<byte>() { 0xFA, 0xFA, 0xFA, 4, 5, 6, 7, 0xFA };
            stateMachine.Reduce0xFAPair(source, 2);
            Assert.AreEqual(true, source.Count == 8);
            Assert.AreEqual(true, source[0] == 0xFA);
            Assert.AreEqual(true, source[1] == 0xFA);
            Assert.AreEqual(true, source[2] == 0xFA);
            Assert.AreEqual(true, source[3] == 4);
            Assert.AreEqual(true, source[6] == 7);
            Assert.AreEqual(true, source[7] == 0xFA);
        }
    }
}