using SharedObjects.Misc;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System;
using System.Windows.Forms;
using SharedObjects.Api;

namespace CanAppTester
{
    
    
    /// <summary>
    ///This is a test class for UtilsTest and is intended
    ///to contain all UtilsTest Unit Tests
    ///</summary>
    [TestClass()]
    public class UtilsTest
    {


        private TestContext testContextInstance;

        /// <summary>
        ///Gets or sets the test context which provides
        ///information about and functionality for the current test run.
        ///</summary>
        public TestContext TestContext
        {
            get
            {
                return testContextInstance;
            }
            set
            {
                testContextInstance = value;
            }
        }

        #region Additional test attributes
        // 
        //You can use the following additional attributes as you write your tests:
        //
        //Use ClassInitialize to run code before running the first test in the class
        //[ClassInitialize()]
        //public static void MyClassInitialize(TestContext testContext)
        //{
        //}
        //
        //Use ClassCleanup to run code after all tests in a class have run
        //[ClassCleanup()]
        //public static void MyClassCleanup()
        //{
        //}
        //
        //Use TestInitialize to run code before running each test
        //[TestInitialize()]
        //public void MyTestInitialize()
        //{
        //}
        //
        //Use TestCleanup to run code after each test has run
        //[TestCleanup()]
        //public void MyTestCleanup()
        //{
        //}
        //
        #endregion


        /// <summary>
        ///A test for Clone
        ///</summary>
        public static void CloneTestHelper<T>(T source)
        {
            T actual;
            actual = Utils.Clone<T>(source);
            Assert.AreEqual(source, actual);
        }

        [TestMethod()]
        public void CloneTest()
        {
            XmlClass.preference obj = new XmlClass.preference();
            obj.name = "Test";
            CloneTestHelper<XmlClass.preference>(obj);
        }

        /// <summary>
        ///A test for addText
        ///</summary>
        [TestMethod()]
        public void addTextTest()
        {
            IPassThruMsg rxmsg1 = DeviceApi.PassThruMsg.getMaskedMsg(SharedObjects.Protocol.Protocols.ISO15765);
            IPassThruMsg rxmsg1Expected = DeviceApi.PassThruMsg.getMaskedMsg(SharedObjects.Protocol.Protocols.ISO15765);
            rxmsg1Expected.Data[0] = (byte)'A';
            rxmsg1Expected.Data[1] = (byte)'B';
            rxmsg1Expected.Data[2] = (byte)'C';
            for (int i0 = 3; i0 < 16; i0++)
            {
                rxmsg1Expected.Data[i0] = (byte)' ';
            }

            int n = 0;
            int nExpected = 16;
            int i = 0;
            int iExpected = 16;
            string text = "ABC";

            Utils.addText(ref rxmsg1, ref n, ref i, text);

            Assert.AreEqual(rxmsg1Expected.GetHashCode(), rxmsg1.GetHashCode());
            Assert.AreEqual(rxmsg1Expected, rxmsg1);
            Assert.AreEqual(nExpected, n);
            Assert.AreEqual(iExpected, i);
        }

        /// <summary>
        ///A test for addrlist_sorter
        ///</summary>
        [TestMethod()]
        public void addrlist_sorterTest()
        {
            XmlClass.vehicle.addrlist gr1 = new XmlClass.vehicle.addrlist();
            XmlClass.vehicle.addrlist gr2 = new XmlClass.vehicle.addrlist();
            XmlClass.vehicle.addrlist gr3 = new XmlClass.vehicle.addrlist();
            XmlClass.vehicle.addrlist gr4 = new XmlClass.vehicle.addrlist();

            gr1.broadcast = true;
            gr2.broadcast = true;
            gr3.broadcast = true;
            gr4.broadcast = false;

            gr1.address = "0x7df";
            gr2.address = "0x7df";
            gr3.address = "0x68";
            gr4.address = "0x7ef";

            Assert.AreEqual(0, Utils.addrlist_sorter(gr1, gr2));
            Assert.AreEqual(-1, Utils.addrlist_sorter(null, gr2));
            Assert.AreEqual(1, Utils.addrlist_sorter(gr1, null));
            Assert.AreEqual(1, Utils.addrlist_sorter(gr1, gr3));
            Assert.AreEqual(-1, Utils.addrlist_sorter(gr1, gr4));
        }

        /// <summary>
        ///A test for commspeed_sorter
        ///</summary>
        [TestMethod()]
        public void commspeed_sorterTest()
        {
            XmlClass.commspeed gr1 = new XmlClass.commspeed();
            XmlClass.commspeed gr2 = new XmlClass.commspeed();
            int expected = 0;
            int actual;
            actual = Utils.commspeed_sorter(gr1, gr2);
            Assert.AreEqual(expected, actual);
        }

        /// <summary>
        ///A test for eculist_sorter
        ///</summary>
        [TestMethod()]
        public void eculist_sorterTest()
        {
            XmlClass.vehicle.ecuData gr1 = new XmlClass.vehicle.ecuData();
            XmlClass.vehicle.ecuData gr2 = new XmlClass.vehicle.ecuData();
            int expected = 0;
            int actual;
            actual = Utils.eculist_sorter(gr1, gr2);
            Assert.AreEqual(expected, actual);
        }

        /// <summary>
        ///A test for extractData
        ///</summary>
        [TestMethod()]
        public void extractDataTest()
        {
            byte[] payload = new byte[] { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05 };
            int headerSize = 5;
            byte[] expected = new byte[] { 0x05 };
            byte[] actual;
            actual = Utils.extractData(payload, headerSize);
            Assert.AreEqual(expected.Length, actual.Length);
            Assert.AreEqual(expected[0], actual[0]);
        }

        /// <summary>
        ///A test for filter_sorter
        ///</summary>
        [TestMethod()]
        public void filter_sorterTest()
        {
            XmlClass.filter gr1 = new XmlClass.filter();
            XmlClass.filter gr2 = new XmlClass.filter();
            int expected = 0;
            int actual;
            actual = Utils.filter_sorter(gr1, gr2);
            Assert.AreEqual(expected, actual);
        }

        /// <summary>
        ///A test for gaugeitem_sorter
        ///</summary>
        [TestMethod()]
        public void gaugeitem_sorterTest()
        {
            XmlClass.gaugeitem gr1 = null;
            XmlClass.gaugeitem gr2 = null;
            int expected = 0;
            int actual;
            actual = Utils.gaugeitem_sorter(gr1, gr2);
            Assert.AreEqual(expected, actual);
        }

        /// <summary>
        ///A test for getCapability
        ///</summary>
        [TestMethod()]
        public void getCapabilityTest()
        {
            int capByte = 0;
            int bit = 0;
            string expected = "0 Engine Speed";
            string actual;
            actual = Utils.getCapability(capByte, bit);
            Assert.AreEqual(expected, actual);
        }

        /// <summary>
        ///A test for getDouble
        ///</summary>
        [TestMethod()]
        public void getDoubleTest()
        {
            object val = "42.55";
            double expected = 42.55;
            double actual;
            actual = Utils.getDouble(val);
            Assert.AreEqual(expected, actual);
        }

        /// <summary>
        ///A test for getDtc
        ///</summary>
        [TestMethod()]
        public void getDtcTest()
        {
            byte[] payload = new byte[] { 0x04, 0x20 };
            int n = 0;
            int nExpected = 2;
            string expected = "P0420";
            string actual;
            actual = Utils.getDtc(payload, ref n);
            Assert.AreEqual(nExpected, n);
            Assert.AreEqual(expected, actual);
        }

        /// <summary>
        ///A test for hexParse
        ///</summary>
        [TestMethod()]
        public void hexParseTest()
        {
            string value = "0x12";
            uint expected = 18;
            uint actual;
            actual = Utils.hexParse(value);
            Assert.AreEqual(expected, actual);
        }

        /// <summary>
        ///A test for icon_sorter
        ///</summary>
        [TestMethod()]
        public void icon_sorterTest()
        {
            XmlClass.icon gr1 = null;
            XmlClass.icon gr2 = null;
            int expected = 0;
            int actual;
            actual = Utils.icon_sorter(gr1, gr2);
            Assert.AreEqual(expected, actual);
        }

        /// <summary>
        ///A test for modegroups_sorter
        ///</summary>
        [TestMethod()]
        public void modegroups_sorterTest()
        {
            XmlClass.modeitem gr1 = new XmlClass.modeitem();
            XmlClass.modeitem gr2 = new XmlClass.modeitem();
            int expected = 0;
            int actual;
            actual = Utils.modegroups_sorter(gr1, gr2);
            Assert.AreEqual(expected, actual);
        }

        /// <summary>
        ///A test for moveString
        ///</summary>
        [TestMethod()]
        public void moveStringTest()
        {
            IPassThruMsg rxmsg1 = DeviceApi.PassThruMsg.getMaskedMsg(SharedObjects.Protocol.Protocols.ISO15765);
            IPassThruMsg rxmsg1Expected = DeviceApi.PassThruMsg.getMaskedMsg(SharedObjects.Protocol.Protocols.ISO15765);
            rxmsg1Expected.Data[0] = (byte)'A';
            rxmsg1Expected.Data[1] = (byte)'B';
            rxmsg1Expected.Data[2] = (byte)'C';
            string str = "ABC";
            int n = 0;
            int nExpected = 3;
            int i = 0;
            int iExpected = 3;
            Utils.moveString(ref rxmsg1, str, ref n, ref i);
            Assert.AreEqual(rxmsg1Expected, rxmsg1);
            Assert.AreEqual(nExpected, n);
            Assert.AreEqual(iExpected, i);
        }

        /// <summary>
        ///A test for pad
        ///</summary>
        [TestMethod()]
        public void padTest()
        {
            IPassThruMsg rxmsg1 = DeviceApi.PassThruMsg.getMaskedMsg(SharedObjects.Protocol.Protocols.ISO15765);
            IPassThruMsg rxmsg1Expected = DeviceApi.PassThruMsg.getMaskedMsg(SharedObjects.Protocol.Protocols.ISO15765);
            rxmsg1Expected.Data[0] = (byte)' ';
            rxmsg1Expected.Data[1] = (byte)' ';
            rxmsg1Expected.Data[2] = (byte)' ';
            int n = 0;
            int nExpected = 3;
            int i = 0;
            int iExpected = 3;
            int padValue = 3;
            Utils.pad(ref rxmsg1, ref n, ref i, padValue);
            Assert.AreEqual(rxmsg1Expected, rxmsg1);
            Assert.AreEqual(nExpected, n);
            Assert.AreEqual(iExpected, i);
        }

        /// <summary>
        ///A test for parameterlist_sorter
        ///</summary>
        [TestMethod()]
        public void parameterlist_sorterTest()
        {
            XmlClass.parameteritem gr1 = null;
            XmlClass.parameteritem gr2 = null;
            int expected = 0;
            int actual;
            actual = Utils.parameterlist_sorter(gr1, gr2);
            Assert.AreEqual(expected, actual);
        }

        /// <summary>
        ///A test for parseDtcCode
        ///</summary>
        [TestMethod()]
        public void parseDtcCodeTest()
        {
            string code = "P0420";
            int expected = 0x0420;
            int actual;
            actual = Utils.parseDtcCode(code);
            Assert.AreEqual(expected, actual);
        }

        /// <summary>
        ///A test for parseDtcCodeExtension
        ///</summary>
        [TestMethod()]
        public void parseDtcCodeExtensionTest()
        {
            string code = "P0420: Catalyst";
            int expected = 0x0420;
            int actual;
            actual = Utils.parseDtcCodeExtension(code);
            Assert.AreEqual(expected, actual);
        }

        /// <summary>
        ///A test for pidgroups_sorter
        ///</summary>
        [TestMethod()]
        public void pidgroups_sorterTest()
        {
            XmlClass.vehicle.pidgroup gr1 = new XmlClass.vehicle.pidgroup();
            XmlClass.vehicle.pidgroup gr2 = new XmlClass.vehicle.pidgroup();
            int expected = 0;
            int actual;
            actual = Utils.pidgroups_sorter(gr1, gr2);
            Assert.AreEqual(expected, actual);
        }

        /// <summary>
        ///A test for pidgroups_sorter
        ///</summary>
        [TestMethod()]
        public void pidgroups_sorterTest1()
        {
            XmlClass.pidgroup gr1 = null;
            XmlClass.pidgroup gr2 = null;
            int expected = 0;
            int actual;
            actual = Utils.pidgroups_sorter(gr1, gr2);
            Assert.AreEqual(expected, actual);
        }

        /// <summary>
        ///A test for pidlist_sorter
        ///</summary>
        [TestMethod()]
        public void pidlist_sorterTest()
        {
            XmlClass.pidgroup.pidlist gr1 = null;
            XmlClass.pidgroup.pidlist gr2 = null;
            int expected = 0;
            int actual;
            actual = Utils.pidlist_sorter(gr1, gr2);
            Assert.AreEqual(expected, actual);
        }

        /// <summary>
        ///A test for sensordata_sorter
        ///</summary>
        [TestMethod()]
        public void sensordata_sorterTest()
        {
            XmlClass.pidgroup.pidlist.sensordata gr1 = null;
            XmlClass.pidgroup.pidlist.sensordata gr2 = null;
            int expected = 0;
            int actual;
            actual = Utils.sensordata_sorter(gr1, gr2);
            Assert.AreEqual(expected, actual);
        }

        /// <summary>
        ///A test for strlen
        ///</summary>
        [TestMethod()]
        public void strlenTest()
        {
            byte[] ba = new byte[] { 0x40, 0x40, 0x20, 0x00 };
            int expected = 3;
            int actual;
            actual = Utils.strlen(ba);
            Assert.AreEqual(expected, actual);
        }

        /// <summary>
        ///A test for unitlist_sorter
        ///</summary>
        [TestMethod()]
        public void unitlist_sorterTest()
        {
            XmlClass.unititem gr1 = null;
            XmlClass.unititem gr2 = null;
            int expected = 0;
            int actual;
            actual = Utils.unitlist_sorter(gr1, gr2);
            Assert.AreEqual(expected, actual);
        }

        /// <summary>
        ///A test for vehicle_sorter
        ///</summary>
        [TestMethod()]
        public void vehicle_sorterTest()
        {
            XmlClass.vehicle gr1 = null;
            XmlClass.vehicle gr2 = null;
            int expected = 0;
            int actual;
            actual = Utils.vehicle_sorter(gr1, gr2);
            Assert.AreEqual(expected, actual);
        }
    }
}