init

Common/DTS.Common.Tests/.svn/entries

@@ -0,0 +1 @@
+12

Common/DTS.Common.Tests/.svn/format

@@ -0,0 +1 @@
+12

Common/DTS.Common.Tests/.svn/pristine/0e/0edb5f4507f5f86fda08ee1682acdcf0c8dd011f.svn-base

@@ -0,0 +1,355 @@
+using DTS.Common.Classes.Sensors;
+using DTS.Common.Enums.Sensors;
+using DTS.Common.Interface.Sensors;
+using NSubstitute;
+using NUnit.Framework;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+
+namespace DTS.Common.Classes.Sensors
+{
+    [TestFixture]
+    class FilterClassShould
+    {
+        List<ISoftwareFilter> softwareFilters = null;
+
+        [SetUp]
+        public void SetUp()
+        {
+            //Arrange 
+            ISoftwareFilter softwareFilter0 = Substitute.For<ISoftwareFilter>();
+            softwareFilter0.ISOCode.Returns('0');
+            softwareFilter0.Frequency.Returns(0.0);
+
+            ISoftwareFilter softwareFilterP = Substitute.For<ISoftwareFilter>();
+            softwareFilterP.ISOCode.Returns('P');
+            softwareFilterP.Frequency.Returns(0.0);
+
+
+            ISoftwareFilter softwareFilterQ = Substitute.For<ISoftwareFilter>();
+            softwareFilterQ.ISOCode.Returns('Q');
+            softwareFilterQ.Frequency.Returns(17.0);
+
+
+            ISoftwareFilter softwareFilterD = Substitute.For<ISoftwareFilter>();
+            softwareFilterD.ISOCode.Returns('D');
+            softwareFilterD.Frequency.Returns(100.00);
+
+
+            ISoftwareFilter softwareFilterC = Substitute.For<ISoftwareFilter>();
+            softwareFilterC.ISOCode.Returns('C');
+            softwareFilterC.Frequency.Returns(300.0);
+
+
+            ISoftwareFilter softwareFilterB = Substitute.For<ISoftwareFilter>();
+            softwareFilterB.ISOCode.Returns('B');
+            softwareFilterB.Frequency.Returns(1000.0);
+
+
+            ISoftwareFilter softwareFilterA = Substitute.For<ISoftwareFilter>();
+            softwareFilterA.ISOCode.Returns('A');
+            softwareFilterA.Frequency.Returns(1650.0);
+
+
+            ISoftwareFilter softwareFilterSFirst = Substitute.For<ISoftwareFilter>();
+            softwareFilterSFirst.ISOCode.Returns('S');
+            softwareFilterSFirst.Frequency.Returns(1700.0);
+
+
+            ISoftwareFilter softwareFilterSSecond = Substitute.For<ISoftwareFilter>();
+            softwareFilterSSecond.ISOCode.Returns('S');
+            softwareFilterSSecond.Frequency.Returns(1750.0);
+
+            softwareFilters = new List<ISoftwareFilter>();
+            softwareFilters.Add(softwareFilter0);
+            softwareFilters.Add(softwareFilterP);
+            softwareFilters.Add(softwareFilterQ);
+            softwareFilters.Add(softwareFilterD);
+            softwareFilters.Add(softwareFilterC);
+            softwareFilters.Add(softwareFilterB);
+            softwareFilters.Add(softwareFilterA);
+            softwareFilters.Add(softwareFilterSFirst);
+            softwareFilters.Add(softwareFilterSSecond);
+        }
+
+        [TearDown]
+        public void TearDown()
+        {
+            softwareFilters = null;
+        }
+
+        [Test]
+        public void GetFilterClassFromString_ShouldReturnUnfiltered_WhenNull()
+        {
+            //Act & Assert
+            var result = FilterClass.GetFilterClassFromString(null);
+            Assert.That(result.FClass, Is.EqualTo(FilterClassType.Unfiltered));
+        }
+
+        [Test]
+        public void GetFilterClassFromString_ShouldReturnUnfiltered_WhenEmpty()
+        {
+            //Act & Assert
+            var result = FilterClass.GetFilterClassFromString("");
+            Assert.That(result.FClass, Is.EqualTo(FilterClassType.Unfiltered));
+        }
+
+        [Test]
+        public void GetFilterClassFromString_ShouldReturnAdhoc_WhenCustom()
+        {
+            //Act & Assert
+            var result = FilterClass.GetFilterClassFromString("1700");
+            Assert.That(result.FClass, Is.EqualTo(FilterClassType.AdHoc));
+            Assert.That(result.Frequency, Is.EqualTo(1700));
+        }
+
+        [Test]
+        public void GetFilterClassFromString_ShouldReturnAdhoc_WhenCustomHz()
+        {
+            //Act & Assert
+            var result = FilterClass.GetFilterClassFromString("1700Hz");
+            Assert.That(result.FClass, Is.EqualTo(FilterClassType.AdHoc));
+            Assert.That(result.Frequency, Is.EqualTo(1700));
+        }
+        [Test]
+        public void GetFilterClassFromString_ShouldReturnCFC10_When10()
+        {
+            //Act & Assert
+            var result = FilterClass.GetFilterClassFromString("10");
+            Assert.That(result.FClass, Is.EqualTo(FilterClassType.CFC10));
+            Assert.That(result.Frequency, Is.EqualTo(17));
+        }
+        [Test]
+        public void GetFilterClassFromString_ShouldReturnCFC10_WhenCFC10()
+        {
+            //Act & Assert
+            var result = FilterClass.GetFilterClassFromString("CFC 10");
+            Assert.That(result.FClass, Is.EqualTo(FilterClassType.CFC10));
+            Assert.That(result.Frequency, Is.EqualTo(17));
+        }
+
+        [Test]
+        public void GetFilterClassFromString_ShouldReturnCFC1000_When1000()
+        {
+            //Act & Assert
+            var result = FilterClass.GetFilterClassFromString("1000");
+            Assert.That(result.FClass, Is.EqualTo(FilterClassType.CFC1000));
+            Assert.That(result.Frequency, Is.EqualTo(1650));
+        }
+        [Test]
+        public void GetFilterClassFromString_ShouldReturnCFC1000_WhenCFC1000()
+        {
+            //Act & Assert
+            var result = FilterClass.GetFilterClassFromString("CFC 1000");
+            Assert.That(result.FClass, Is.EqualTo(FilterClassType.CFC1000));
+            Assert.That(result.Frequency, Is.EqualTo(1650));
+        }
+
+        [Test]
+        public void GetFilterClassFromString_ShouldReturnCFC180_When180()
+        {
+            //Act & Assert
+            var result = FilterClass.GetFilterClassFromString("180");
+            Assert.That(result.FClass, Is.EqualTo(FilterClassType.CFC180));
+            Assert.That(result.Frequency, Is.EqualTo(300));
+        }
+        [Test]
+        public void GetFilterClassFromString_ShouldReturnCFC180_WhenCFC180()
+        {
+            //Act & Assert
+            var result = FilterClass.GetFilterClassFromString("CFC 180");
+            Assert.That(result.FClass, Is.EqualTo(FilterClassType.CFC180));
+            Assert.That(result.Frequency, Is.EqualTo(300));
+        }
+
+        [Test]
+        public void GetFilterClassFromString_ShouldReturnCFC60_When60()
+        {
+            //Act & Assert
+            var result = FilterClass.GetFilterClassFromString("60");
+            Assert.That(result.FClass, Is.EqualTo(FilterClassType.CFC60));
+            Assert.That(result.Frequency, Is.EqualTo(100));
+        }
+        [Test]
+        public void GetFilterClassFromString_ShouldReturnCFC60_WhenCFC60()
+        {
+            //Act & Assert
+            var result = FilterClass.GetFilterClassFromString("CFC 60");
+            Assert.That(result.FClass, Is.EqualTo(FilterClassType.CFC60));
+            Assert.That(result.Frequency, Is.EqualTo(100));
+        }
+
+        [Test]
+        public void GetFilterClassFromString_ShouldReturnCFC600_When600()
+        {
+            //Act & Assert
+            var result = FilterClass.GetFilterClassFromString("600");
+            Assert.That(result.FClass, Is.EqualTo(FilterClassType.CFC600));
+            Assert.That(result.Frequency, Is.EqualTo(1000));
+        }
+        [Test]
+        public void GetFilterClassFromString_ShouldReturnCFC600_WhenCFC600()
+        {
+            //Act & Assert
+            var result = FilterClass.GetFilterClassFromString("CFC 600");
+            Assert.That(result.FClass, Is.EqualTo(FilterClassType.CFC600));
+            Assert.That(result.Frequency, Is.EqualTo(1000));
+        }
+
+        [Test]
+        public void GetFilterClassFromString_ShouldReturnUnfiltered_WhenInvalidInput()
+        {
+            //Act & Assert
+            var result = FilterClass.GetFilterClassFromString("fg342");
+            Assert.That(result.FClass, Is.EqualTo(FilterClassType.Unfiltered));
+        }
+
+        [Test]
+        public void GetFilterClassFromString_ShouldReturnNone_WhenNone()
+        {
+            //Act & Assert
+            var result = FilterClass.GetFilterClassFromString("None");
+            Assert.That(result.FClass, Is.EqualTo(FilterClassType.None));
+        }
+
+
+        [Test]
+        public void GetDefaultFilterClass_ShouldReturnUnfiltered_When0()
+        {
+            //Arrange
+            softwareFilters.Find(p => p.ISOCode == '0').IsDefault.Returns(true);
+
+            //Act & Assert
+            var result = FilterClass.GetDefaultFilterClass(softwareFilters);
+            Assert.That(result.FClass, Is.EqualTo(FilterClassType.Unfiltered));
+        }
+
+        [Test]
+        public void GetDefaultFilterClass_ShouldReturnNone_WhenP()
+        {
+            //Arrange
+            softwareFilters.Find(p => p.ISOCode == 'P').IsDefault.Returns(true);
+
+            //Act & Assert
+            var result = FilterClass.GetDefaultFilterClass(softwareFilters);
+            Assert.That(result.FClass, Is.EqualTo(FilterClassType.None));
+        }
+
+        [Test]
+        public void GetDefaultFilterClass_ShouldReturnCFC1000_WhenA()
+        {
+            //Arrange
+            softwareFilters.Find(p => p.ISOCode == 'A').IsDefault.Returns(true);
+
+            //Act & Assert
+            var result = FilterClass.GetDefaultFilterClass(softwareFilters);
+            Assert.That(result.FClass, Is.EqualTo(FilterClassType.CFC1000));
+        }
+
+        [Test]
+        public void GetDefaultFilterClass_ShouldReturnCFC600_WhenB()
+        {
+            //Arrange
+            softwareFilters.Find(p => p.ISOCode == 'B').IsDefault.Returns(true);
+
+            //Act & Assert
+            var result = FilterClass.GetDefaultFilterClass(softwareFilters);
+            Assert.That(result.FClass, Is.EqualTo(FilterClassType.CFC600));
+        }
+
+        [Test]
+        public void GetDefaultFilterClass_ShouldReturnCFC600_WhenC()
+        {
+            //Arrange
+            softwareFilters.Find(p => p.ISOCode == 'C').IsDefault.Returns(true);
+
+            //Act & Assert
+            var result = FilterClass.GetDefaultFilterClass(softwareFilters);
+            Assert.That(result.FClass, Is.EqualTo(FilterClassType.CFC180));
+        }
+
+        [Test]
+        public void GetDefaultFilterClass_ShouldReturnCFC600_WhenD()
+        {
+            //Arrange
+            softwareFilters.Find(p => p.ISOCode == 'D').IsDefault.Returns(true);
+
+            //Act & Assert
+            var result = FilterClass.GetDefaultFilterClass(softwareFilters);
+            Assert.That(result.FClass, Is.EqualTo(FilterClassType.CFC60));
+        }
+
+        [Test]
+        public void GetDefaultFilterClass_ShouldReturnAdhoc1700_WhenSAnd1700()
+        {
+            //Arrange
+            softwareFilters.Find(p => p.ISOCode == 'S' && p.Frequency == 1700.00).IsDefault.Returns(true);
+
+            //Act & Assert
+            var result = FilterClass.GetDefaultFilterClass(softwareFilters);
+            Assert.That(result.FClass, Is.EqualTo(FilterClassType.AdHoc));
+            Assert.That(result.Frequency, Is.EqualTo(1700.00));
+        }
+
+        [Test]
+        public void GetDefaultFilterClass_ShouldReturnCFC1000_WhenNull()
+        {
+            //Arrange
+            softwareFilters = null;
+
+            //Act & Assert
+            var result = FilterClass.GetDefaultFilterClass(softwareFilters);
+            Assert.That(result.FClass, Is.EqualTo(FilterClassType.CFC1000));
+        }
+
+        [Test]
+        public void GetDefaultFilterClass_ShouldReturnCFC1000_WhenEmptyCollection()
+        {
+            //Arrange
+            softwareFilters = new List<ISoftwareFilter>();
+
+            //Act & Assert
+            var result = FilterClass.GetDefaultFilterClass(softwareFilters);
+            Assert.That(result.FClass, Is.EqualTo(FilterClassType.CFC1000));
+        }
+
+
+        [Test]
+        public void GetFrequencyFromFilterClassType_ShouldReturn1650_WhenCFC1000()
+        {
+            //Act & Assert
+            var result = FilterClass.GetFrequencyFromFilterClassType(FilterClassType.CFC1000);
+            Assert.That(result, Is.EqualTo(1650));
+        }
+
+        [Test]
+        public void GetFrequencyFromFilterClassType_ShouldReturn0_WhenNone()
+        {
+            //Act & Assert
+            var result = FilterClass.GetFrequencyFromFilterClassType(FilterClassType.None);
+            Assert.That(result, Is.EqualTo(0));
+        }
+
+        [Test]
+        public void GetFrequencyFromFilterClassType_ShouldReturnMinus2_WhenUnfiltered()
+        {
+            //Act & Assert
+            var result = FilterClass.GetFrequencyFromFilterClassType(FilterClassType.Unfiltered);
+            Assert.That(result, Is.EqualTo(-2));
+        }
+
+        [Test]
+        public void GetFrequencyFromFilterClassType_ShouldThrowException_WhenAdHoc()
+        {
+            //Act & Assert
+            Assert.That(
+              () => FilterClass.GetFrequencyFromFilterClassType(FilterClassType.AdHoc)
+               , Throws.TypeOf<Exception>()
+          .With
+          .Property("Message")
+          .EqualTo("GetFrequencyFromFilterClassType: AdHoc FilterClassType does not have frequency associated"));
+        }
+    }
+}

Common/DTS.Common.Tests/.svn/pristine/30/30cb33edf403173337602596bcf3242865c0d75d.svn-base

@@ -0,0 +1,254 @@
+using DTS.Common.Enums.Sensors;
+using DTS.Common.Interface.Channels;
+using DTS.Common.Interface.Groups.GroupList;
+using DTS.Common.Interface.Sensors;
+
+using NSubstitute;
+using NUnit.Framework;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace DTS.Common.Classes.Groups
+{
+    [TestFixture]
+    class GroupChannelShould
+    {
+
+        [Test]
+        public void GetFilterClassFromISOCode_ShouldReturnCFC1000WhenIsoIsA()
+        {
+            //Arrange
+            ISoftwareFilter sf1 = Substitute.For<ISoftwareFilter>();
+            ISoftwareFilter sf2 = Substitute.For<ISoftwareFilter>();
+            List<ISoftwareFilter> filters = new List<ISoftwareFilter>();
+            filters.Add(sf1);
+            filters.Add(sf2);
+
+            IGroup group = Substitute.For<IGroup>();
+
+            IChannelSetting chs1 = Substitute.For<IChannelSetting>();
+            chs1.SettingName.Returns("FilterClass");
+            List<IChannelSetting> channelSettings = new List<IChannelSetting>();
+            channelSettings.Add(chs1);
+            IGroupChannel groupChannel = new GroupChannel(false, "TestGroup", group, channelSettings.ToArray());
+
+            //Act
+            var result = groupChannel.GetFilterClassFromISOCode(filters.ToArray(), "???????????????A");
+
+            //Assert 
+            Assert.That(result.FClass, Is.EqualTo(FilterClassType.CFC1000));
+        }
+
+        [Test]
+        public void GetFilterClassFromISOCode_ShouldReturnCFC600WhenIsoIsB()
+        {
+            //Arrange
+            ISoftwareFilter sf1 = Substitute.For<ISoftwareFilter>();
+            ISoftwareFilter sf2 = Substitute.For<ISoftwareFilter>();
+            List<ISoftwareFilter> filters = new List<ISoftwareFilter>();
+            filters.Add(sf1);
+            filters.Add(sf2);
+
+            IGroup group = Substitute.For<IGroup>();
+
+            IChannelSetting chs1 = Substitute.For<IChannelSetting>();
+            chs1.SettingName.Returns("FilterClass");
+            List<IChannelSetting> channelSettings = new List<IChannelSetting>();
+            channelSettings.Add(chs1);
+            IGroupChannel groupChannel = new GroupChannel(false, "TestGroup", group, channelSettings.ToArray());
+
+            //Act
+            var result = groupChannel.GetFilterClassFromISOCode(filters.ToArray(), "???????????????B");
+
+            //Assert 
+            Assert.That(result.FClass, Is.EqualTo(FilterClassType.CFC600));
+        }
+
+        [Test]
+        public void GetFilterClassFromISOCode_ShouldReturnCFC180WhenIsoIsC()
+        {
+            //Arrange
+            ISoftwareFilter sf1 = Substitute.For<ISoftwareFilter>();
+            ISoftwareFilter sf2 = Substitute.For<ISoftwareFilter>();
+            List<ISoftwareFilter> filters = new List<ISoftwareFilter>();
+            filters.Add(sf1);
+            filters.Add(sf2);
+
+            IGroup group = Substitute.For<IGroup>();
+
+            IChannelSetting chs1 = Substitute.For<IChannelSetting>();
+            chs1.SettingName.Returns("FilterClass");
+            List<IChannelSetting> channelSettings = new List<IChannelSetting>();
+            channelSettings.Add(chs1);
+            IGroupChannel groupChannel = new GroupChannel(false, "TestGroup", group, channelSettings.ToArray());
+
+            //Act
+            var result = groupChannel.GetFilterClassFromISOCode(filters.ToArray(), "???????????????C");
+
+            //Assert 
+            Assert.That(result.FClass, Is.EqualTo(FilterClassType.CFC180));
+        }
+
+        [Test]
+        public void GetFilterClassFromISOCode_ShouldReturnCFC60WhenIsoIsD()
+        {
+            //Arrange
+            ISoftwareFilter sf1 = Substitute.For<ISoftwareFilter>();
+            ISoftwareFilter sf2 = Substitute.For<ISoftwareFilter>();
+            List<ISoftwareFilter> filters = new List<ISoftwareFilter>();
+            filters.Add(sf1);
+            filters.Add(sf2);
+
+            IGroup group = Substitute.For<IGroup>();
+
+            IChannelSetting chs1 = Substitute.For<IChannelSetting>();
+            chs1.SettingName.Returns("FilterClass");
+            List<IChannelSetting> channelSettings = new List<IChannelSetting>();
+            channelSettings.Add(chs1);
+            IGroupChannel groupChannel = new GroupChannel(false, "TestGroup", group, channelSettings.ToArray());
+
+            //Act
+            var result = groupChannel.GetFilterClassFromISOCode(filters.ToArray(), "???????????????D");
+
+            //Assert 
+            Assert.That(result.FClass, Is.EqualTo(FilterClassType.CFC60));
+        }
+
+        [Test]
+        public void GetFilterClassFromISOCode_ShouldReturnUnfilteredWhenIsoIs0()
+        {
+            //Arrange
+            ISoftwareFilter sf1 = Substitute.For<ISoftwareFilter>();
+            ISoftwareFilter sf2 = Substitute.For<ISoftwareFilter>();
+            List<ISoftwareFilter> filters = new List<ISoftwareFilter>();
+            filters.Add(sf1);
+            filters.Add(sf2);
+
+            IGroup group = Substitute.For<IGroup>();
+
+            IChannelSetting chs1 = Substitute.For<IChannelSetting>();
+            chs1.SettingName.Returns("FilterClass");
+            List<IChannelSetting> channelSettings = new List<IChannelSetting>();
+            channelSettings.Add(chs1);
+            IGroupChannel groupChannel = new GroupChannel(false, "TestGroup", group, channelSettings.ToArray());
+
+            //Act
+            var result = groupChannel.GetFilterClassFromISOCode(filters.ToArray(), "???????????????0");
+
+            //Assert 
+            Assert.That(result.FClass, Is.EqualTo(FilterClassType.Unfiltered));
+        }
+
+        public void GetFilterClassFromISOCode_ShouldReturnNoneWhenIsoIsP()
+        {
+            //Arrange
+            ISoftwareFilter sf1 = Substitute.For<ISoftwareFilter>();
+            ISoftwareFilter sf2 = Substitute.For<ISoftwareFilter>();
+            List<ISoftwareFilter> filters = new List<ISoftwareFilter>();
+            filters.Add(sf1);
+            filters.Add(sf2);
+
+            IGroup group = Substitute.For<IGroup>();
+
+            IChannelSetting chs1 = Substitute.For<IChannelSetting>();
+            chs1.SettingName.Returns("FilterClass");
+            List<IChannelSetting> channelSettings = new List<IChannelSetting>();
+            channelSettings.Add(chs1);
+            IGroupChannel groupChannel = new GroupChannel(false, "TestGroup", group, channelSettings.ToArray());
+
+            //Act
+            var result = groupChannel.GetFilterClassFromISOCode(filters.ToArray(), "???????????????P");
+
+            //Assert 
+            Assert.That(result.FClass, Is.EqualTo(FilterClassType.None));
+        }
+
+        [Test]
+        public void GetFilterClassFromISOCode_ShouldReturnAdhocWhenIsoIsAdhoc1800()
+        {
+            //Arrange
+            ISoftwareFilter sf1 = Substitute.For<ISoftwareFilter>();
+            ISoftwareFilter sf2 = Substitute.For<ISoftwareFilter>();
+            sf1.Frequency.Returns(1800);
+            sf1.ISOCode.Returns('S');
+
+            List<ISoftwareFilter> filters = new List<ISoftwareFilter>();
+            filters.Add(sf1);
+            filters.Add(sf2);
+
+            IGroup group = Substitute.For<IGroup>();
+
+            IChannelSetting chs1 = Substitute.For<IChannelSetting>();
+            chs1.SettingName.Returns("FilterClass");
+            List<IChannelSetting> channelSettings = new List<IChannelSetting>();
+            channelSettings.Add(chs1);
+            IGroupChannel groupChannel = new GroupChannel(false, "TestGroup", group, channelSettings.ToArray());
+
+            //Act
+            var result = groupChannel.GetFilterClassFromISOCode(filters.ToArray(), "???????????????S");
+
+            //Assert 
+            Assert.That(result.FClass, Is.EqualTo(FilterClassType.AdHoc));
+            Assert.That(result.Frequency, Is.EqualTo(1800));
+        }
+
+        [Test]
+        public void GetFilterClassFromISOCode_ShouldReturnCFC1000WhenNoAdhocFilter()
+        {
+            //Arrange
+            ISoftwareFilter sf1 = Substitute.For<ISoftwareFilter>();
+            ISoftwareFilter sf2 = Substitute.For<ISoftwareFilter>();
+            sf1.Frequency.Returns(1650);
+            sf1.ISOCode.Returns('A');
+
+            List<ISoftwareFilter> filters = new List<ISoftwareFilter>();
+            filters.Add(sf1);
+            filters.Add(sf2);
+
+            IGroup group = Substitute.For<IGroup>();
+
+            IChannelSetting chs1 = Substitute.For<IChannelSetting>();
+            chs1.SettingName.Returns("FilterClass");
+            List<IChannelSetting> channelSettings = new List<IChannelSetting>();
+            channelSettings.Add(chs1);
+            IGroupChannel groupChannel = new GroupChannel(false, "TestGroup", group, channelSettings.ToArray());
+
+            //Act
+            var result = groupChannel.GetFilterClassFromISOCode(filters.ToArray(), "???????????????S");
+
+            //Assert 
+            Assert.That(result.FClass, Is.EqualTo(FilterClassType.CFC1000));
+
+        }
+
+        [Test]
+        public void GetFilterClassFromISOCode_ShouldReturnCFC1000WhenIsoIsNotValid()
+        {
+            //Arrange
+            ISoftwareFilter sf1 = Substitute.For<ISoftwareFilter>();
+            ISoftwareFilter sf2 = Substitute.For<ISoftwareFilter>();
+            List<ISoftwareFilter> filters = new List<ISoftwareFilter>();
+            filters.Add(sf1);
+            filters.Add(sf2);
+
+            IGroup group = Substitute.For<IGroup>();
+
+            IChannelSetting chs1 = Substitute.For<IChannelSetting>();
+            chs1.SettingName.Returns("FilterClass");
+            List<IChannelSetting> channelSettings = new List<IChannelSetting>();
+            channelSettings.Add(chs1);
+            IGroupChannel groupChannel = new GroupChannel(false, "TestGroup", group, channelSettings.ToArray());
+
+            //Act
+            var result = groupChannel.GetFilterClassFromISOCode(filters.ToArray(), "???????????????H");
+
+            //Assert 
+            Assert.That(result.FClass, Is.EqualTo(FilterClassType.CFC1000));
+        }
+
+
+    }
+}

Common/DTS.Common.Tests/.svn/pristine/37/3753c91cee336d90e832f5dffda1e364bae6d2e5.svn-base

@@ -0,0 +1,79 @@
+using DTS.Common.Classes.Sensors;
+using DTS.Common.Utils;
+using NUnit.Framework;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace DTS.Common.Tests
+{
+    public class LinearizationFormulaShould
+    {
+        [Test]
+        public void GetLinearizedValue_ShouldReturnCorrectEU_OnNonLinearAndNonProportional()
+        {
+            //Arrange
+            LinearizationFormula linearizationFormula = new LinearizationFormula();
+            linearizationFormula.PolynomialCoefficients = new double[] { 1657.882, 4368.774, 204.5695, 24.8535 };
+            //Act
+            //Assert 
+            var resultEU = linearizationFormula.GetLinearizedValue(-0.39272, 5, false);
+            Assert.That(resultEU, Is.EqualTo(-27.7773).Within(.0005));
+
+            var resultEU2 = linearizationFormula.GetLinearizedValue(-0.14947, 5, false);
+            Assert.That(resultEU2, Is.EqualTo(1009.369).Within(.0005));
+
+            var resultEU3 = linearizationFormula.GetLinearizedValue(0.73579, 5, false);
+            Assert.That(resultEU3, Is.EqualTo(4993.034).Within(.0005));
+
+            var resultEU4 = linearizationFormula.GetLinearizedValue(0.30645, 5, false);
+            Assert.That(resultEU4, Is.EqualTo(3016.62).Within(.0005));
+
+        }
+        [Test]
+        public void GetLinearizedValue_ShouldReturnCorrectEU_OnNonLinearAndProportional()
+        {
+            //Arrange
+            LinearizationFormula linearizationFormula = new LinearizationFormula();
+            linearizationFormula.PolynomialCoefficients = new double[] { 1657.882, 4368.774, 204.5695, 24.8535 };
+            //Act
+            //Assert 
+            var resultEU = linearizationFormula.GetLinearizedValue(-0.39272, 5, true);
+            Assert.That(resultEU, Is.Not.EqualTo(-27.7773).Within(.0005));
+            var resultEU2 = linearizationFormula.GetLinearizedValue(-0.14947, 5, true);
+            Assert.That(resultEU2, Is.Not.EqualTo(1009.369).Within(.0005));
+
+        }
+
+        [Test]
+        public void GetLinearizedValue_ShouldReturnCorrectEU_OnNonLinearAndProportionalSpecifiedAsNull()
+        {
+            //Arrange
+            LinearizationFormula linearizationFormula = new LinearizationFormula();
+            linearizationFormula.PolynomialCoefficients = new double[] { 1657.882, 4368.774, 204.5695, 24.8535 };
+            //Act
+            //Assert 
+            var resultEU = linearizationFormula.GetLinearizedValue(-0.39272, 5, null);
+            Assert.That(resultEU, Is.Not.EqualTo(-27.7773).Within(.0005));
+            var resultEU2 = linearizationFormula.GetLinearizedValue(-0.14947, 5, null);
+            Assert.That(resultEU2, Is.Not.EqualTo(1009.369).Within(.0005));
+
+        }
+
+        [Test]
+        public void GetLinearizedValue_ShouldNonLinearStyleBePolynomial_ByDefault()
+        {
+            //Arrange
+            LinearizationFormula linearizationFormula = new LinearizationFormula();
+            linearizationFormula.PolynomialCoefficients = new double[] { 1657.882, 4368.774, 204.5695, 24.8535 };
+
+            //Act
+            //Assert 
+            Assert.That(linearizationFormula.NonLinearStyle, Is.EqualTo(Enums.Sensors.NonLinearStyles.Polynomial));
+
+        }
+
+    }
+}

Common/DTS.Common.Tests/.svn/pristine/3f/3f0e7414888ebac6f87c110ec06daa7611f5ddb4.svn-base

@@ -0,0 +1,82 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProjectGuid>{4CE21BEC-2C24-4E62-BD33-F689016F331D}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>DTS.Common.Tests</RootNamespace>
+    <AssemblyName>DTS.Common.Tests</AssemblyName>
+    <TargetFrameworkVersion>v4.8</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+    <Deterministic>true</Deterministic>
+    <TargetFrameworkProfile />
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <PlatformTarget>x64</PlatformTarget>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x64'">
+    <DebugSymbols>true</DebugSymbols>
+    <OutputPath>bin\x64\Debug\</OutputPath>
+    <PlatformTarget>x64</PlatformTarget>
+    <LangVersion>7.3</LangVersion>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|AnyCPU'">
+    <DebugSymbols>true</DebugSymbols>
+    <OutputPath>bin\x64\Release\</OutputPath>
+    <PlatformTarget>x64</PlatformTarget>
+    <LangVersion>7.3</LangVersion>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|x64'">
+    <DebugSymbols>true</DebugSymbols>
+    <OutputPath>bin\x64\Release\</OutputPath>
+    <PlatformTarget>x64</PlatformTarget>
+    <LangVersion>7.3</LangVersion>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="Castle.Core">
+      <HintPath>..\..\DataPRO\packages\Castle.Core.4.4.0\lib\net45\Castle.Core.dll</HintPath>
+    </Reference>
+    <Reference Include="NSubstitute">
+      <HintPath>..\..\DataPRO\packages\NSubstitute.4.2.1\lib\net46\NSubstitute.dll</HintPath>
+    </Reference>
+    <Reference Include="nunit.framework">
+      <HintPath>..\..\DataPRO\packages\NUnit.3.12.0\lib\net45\nunit.framework.dll</HintPath>
+    </Reference>
+    <Reference Include="NUnit3.TestAdapter, Version=3.13.0.0, Culture=neutral, PublicKeyToken=4cb40d35494691ac, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\DataPRO\packages\NUnit3TestAdapter.3.14.0\build\net35\NUnit3.TestAdapter.dll</HintPath>
+    </Reference>
+    <Reference Include="System" />
+    <Reference Include="System.Core" />
+    <Reference Include="System.Runtime.CompilerServices.Unsafe">
+      <HintPath>..\..\DataPRO\packages\System.Runtime.CompilerServices.Unsafe.4.5.2\lib\netstandard2.0\System.Runtime.CompilerServices.Unsafe.dll</HintPath>
+    </Reference>
+    <Reference Include="System.Threading.Tasks.Extensions">
+      <HintPath>..\..\DataPRO\packages\System.Threading.Tasks.Extensions.4.5.3\lib\netstandard2.0\System.Threading.Tasks.Extensions.dll</HintPath>
+    </Reference>
+    <Reference Include="System.Xml.Linq" />
+    <Reference Include="System.Data.DataSetExtensions" />
+    <Reference Include="Microsoft.CSharp" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Net.Http" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="ChannelTypeUtilityShould.cs" />
+    <Compile Include="FilterClassShould.cs" />
+    <Compile Include="GroupChannelShould.cs" />
+    <Compile Include="LinearizationFormulaShould.cs" />
+    <Compile Include="NetworkUtilsShould.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\..\Common\DTS.Common\DTS.Common.csproj">
+      <Project>{f7a0804f-61a4-40ae-83d0-f1137622b592}</Project>
+      <Name>DTS.Common</Name>
+    </ProjectReference>
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+</Project>

Common/DTS.Common.Tests/.svn/pristine/41/411ddc977426519b0c89a70f77b80ac4194dd2fd.svn-base

@@ -0,0 +1,99 @@
+using DTS.Common.Utils;
+using NUnit.Framework;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace DTS.Common.Tests
+{
+    [TestFixture]
+    class NetworkUtilsShould
+    {
+        [Test]
+        public void TryParseConnectionString_ShouldReturnFalseWhenConnectionStringIsNull()
+        {
+            //Arrange
+
+            //Act
+            var result = NetworkUtils.TryParseConnectionString(null, out _);
+
+            //Assert 
+            Assert.That(result, Is.False);
+        }
+
+        [Test]
+        public void TryParseConnectionString_ShouldReturnFalseWhenConnectionStringDoesNotContainIp()
+        {
+            //Arrange
+            var connectionString = @"\\?\usb#vid_1cb9&pid_001b#6&284bed14&2&1#{fb10e3ff-ece3-410e-beeb-719096813fb9}";
+            //Act
+            var result = NetworkUtils.TryParseConnectionString(connectionString, out _);
+
+            //Assert 
+            Assert.That(result, Is.False);
+        }
+
+        [Test]
+        public void TryParseConnectionString_ShouldReturnTrueWhenConnectionStringContainsIpAndPort()
+        {
+            //Arrange
+            var connectionString = @"192.168.1.61:8083";
+            string ipAddress;
+
+            //Act
+            var result = NetworkUtils.TryParseConnectionString(connectionString, out ipAddress);
+
+            //Assert 
+            Assert.That(result, Is.True);
+            Assert.That(ipAddress, Is.EqualTo("192.168.1.61"));
+        }
+
+
+        [Test]
+        public void TryParseConnectionString_ShouldReturnTrueWhenConnectionStringContainsOnlyIp()
+        {
+            //Arrange
+            var connectionString = @"192.168.1.61";
+            string ipAddress;
+
+            //Act
+            var result = NetworkUtils.TryParseConnectionString(connectionString, out ipAddress);
+
+            //Assert 
+            Assert.That(result, Is.True);
+            Assert.That(ipAddress, Is.EqualTo("192.168.1.61"));
+        }
+
+        [Test]
+        public void TryParseConnectionString_ShouldReturnTrueWhenConnectionStringContainsOnlyIpWithProtocolUDP()
+        {
+            //Arrange
+            var connectionString = @"udp://192.168.1.10:8200 ";
+            string ipAddress;
+
+            //Act
+            var result = NetworkUtils.TryParseConnectionString(connectionString, out ipAddress);
+
+            //Assert 
+            Assert.That(result, Is.True);
+            Assert.That(ipAddress, Is.EqualTo("192.168.1.10"));
+        }
+
+        [Test]
+        public void TryParseConnectionString_ShouldReturnTrueWhenConnectionStringContainsOnlyIpWithProtocolHTTP()
+        {
+            //Arrange
+            var connectionString = @"http://192.168.1.10:8200 ";
+            string ipAddress;
+
+            //Act
+            var result = NetworkUtils.TryParseConnectionString(connectionString, out ipAddress);
+
+            //Assert 
+            Assert.That(result, Is.True);
+            Assert.That(ipAddress, Is.EqualTo("192.168.1.10"));
+        }
+    }
+}

Common/DTS.Common.Tests/.svn/pristine/91/91606def456d6650af4e0bdb8cce677c087466ae.svn-base

@@ -0,0 +1,77 @@
+using DTS.Common.Classes.Sensors;
+using NUnit.Framework;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace DTS.Common.Tests
+{
+    public class ChannelTypeUtilityShould
+    {
+        public static Array GetKnownChannelTypes()
+        {
+            var testValuesFromEnum = new List<string>();
+            var values = Enum.GetValues(typeof(KnownChannelTypes)).Cast<KnownChannelTypes>().Select(x => x.ToString()).ToArray();
+            foreach (var value in values)
+            {
+                testValuesFromEnum.Add($"{value}087155.1");
+            }
+            return testValuesFromEnum.ToArray();
+        }
+
+        [Test]
+        public void ParseSensorKnownChannelType_ShouldRetuenEmpty_WhenPassedNull()
+        {
+            //Arrange
+            //Act
+            var res = ChannelTypeUtility.ParseSensorKnownChannelType(null);
+            //Assert
+            Assert.IsNotNull(res);
+            Assert.That(res, Is.EqualTo(string.Empty));
+        }
+
+        [Test]
+        public void ParseSensorKnownChannelType_ShouldRetuenEmpty_WhenPassedLessThan2Char()
+        {
+            //Arrange
+            //Act
+            var res = ChannelTypeUtility.ParseSensorKnownChannelType("A");
+            //Assert
+            Assert.IsNotNull(res);
+            Assert.That(res, Is.EqualTo(string.Empty));
+        }
+
+        [Test]
+        public void ParseSensorKnownChannelType_ShouldRetuenEmpty_WhenPassedNameWithUnknown2Char()
+        {
+            //Arrange
+            //Act
+            var res = ChannelTypeUtility.ParseSensorKnownChannelType("XA087155.1");
+            //Assert
+            Assert.IsNotNull(res);
+            Assert.That(res, Is.EqualTo(string.Empty));
+        }
+
+        [Test]
+        public void ParseSensorKnownChannelType_ShouldRetuenEmpty_WhenPassedEmptyString()
+        {
+            //Arrange
+            //Act
+            var res = ChannelTypeUtility.ParseSensorKnownChannelType("");
+            //Assert
+            Assert.IsNotNull(res);
+            Assert.That(res, Is.EqualTo(""));
+        }
+
+        [TestCaseSource("GetKnownChannelTypes")]
+        public void ParseSensorKnownChannelType_ShouldRetuenCorrectTag_WhenPassedSensorNameWithCorrectPrefix(string sensorName)
+        {
+            //Arrange
+            //Act
+            var res = ChannelTypeUtility.ParseSensorKnownChannelType(sensorName);
+            //Assert
+            Assert.IsNotNull(res);
+            Enum.IsDefined(typeof(KnownChannelTypes), res);
+        }
+    }
+}

Common/DTS.Common.Tests/.svn/pristine/d1/d1750c1d6a2f62ea748a56635a328acc0a2aed48.svn-base

@@ -0,0 +1,36 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("DTS.Common.Tests")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("DTS.Common.Tests")]
+[assembly: AssemblyCopyright("Copyright ©  2020")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible
+// to COM components.  If you need to access a type in this assembly from
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("4ce21bec-2c24-4e62-bd33-f689016f331d")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Build and Revision Numbers
+// by using the '*' as shown below:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]

Common/DTS.Common.Tests/ChannelTypeUtilityShould.cs

@@ -0,0 +1,77 @@
+using DTS.Common.Classes.Sensors;
+using NUnit.Framework;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace DTS.Common.Tests
+{
+    public class ChannelTypeUtilityShould
+    {
+        public static Array GetKnownChannelTypes()
+        {
+            var testValuesFromEnum = new List<string>();
+            var values = Enum.GetValues(typeof(KnownChannelTypes)).Cast<KnownChannelTypes>().Select(x => x.ToString()).ToArray();
+            foreach (var value in values)
+            {
+                testValuesFromEnum.Add($"{value}087155.1");
+            }
+            return testValuesFromEnum.ToArray();
+        }
+
+        [Test]
+        public void ParseSensorKnownChannelType_ShouldRetuenEmpty_WhenPassedNull()
+        {
+            //Arrange
+            //Act
+            var res = ChannelTypeUtility.ParseSensorKnownChannelType(null);
+            //Assert
+            Assert.IsNotNull(res);
+            Assert.That(res, Is.EqualTo(string.Empty));
+        }
+
+        [Test]
+        public void ParseSensorKnownChannelType_ShouldRetuenEmpty_WhenPassedLessThan2Char()
+        {
+            //Arrange
+            //Act
+            var res = ChannelTypeUtility.ParseSensorKnownChannelType("A");
+            //Assert
+            Assert.IsNotNull(res);
+            Assert.That(res, Is.EqualTo(string.Empty));
+        }
+
+        [Test]
+        public void ParseSensorKnownChannelType_ShouldRetuenEmpty_WhenPassedNameWithUnknown2Char()
+        {
+            //Arrange
+            //Act
+            var res = ChannelTypeUtility.ParseSensorKnownChannelType("XA087155.1");
+            //Assert
+            Assert.IsNotNull(res);
+            Assert.That(res, Is.EqualTo(string.Empty));
+        }
+
+        [Test]
+        public void ParseSensorKnownChannelType_ShouldRetuenEmpty_WhenPassedEmptyString()
+        {
+            //Arrange
+            //Act
+            var res = ChannelTypeUtility.ParseSensorKnownChannelType("");
+            //Assert
+            Assert.IsNotNull(res);
+            Assert.That(res, Is.EqualTo(""));
+        }
+
+        [TestCaseSource("GetKnownChannelTypes")]
+        public void ParseSensorKnownChannelType_ShouldRetuenCorrectTag_WhenPassedSensorNameWithCorrectPrefix(string sensorName)
+        {
+            //Arrange
+            //Act
+            var res = ChannelTypeUtility.ParseSensorKnownChannelType(sensorName);
+            //Assert
+            Assert.IsNotNull(res);
+            Enum.IsDefined(typeof(KnownChannelTypes), res);
+        }
+    }
+}

Common/DTS.Common.Tests/DTS.Common.Tests.csproj

@@ -0,0 +1,82 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProjectGuid>{4CE21BEC-2C24-4E62-BD33-F689016F331D}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>DTS.Common.Tests</RootNamespace>
+    <AssemblyName>DTS.Common.Tests</AssemblyName>
+    <TargetFrameworkVersion>v4.8</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+    <Deterministic>true</Deterministic>
+    <TargetFrameworkProfile />
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <PlatformTarget>x64</PlatformTarget>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x64'">
+    <DebugSymbols>true</DebugSymbols>
+    <OutputPath>bin\x64\Debug\</OutputPath>
+    <PlatformTarget>x64</PlatformTarget>
+    <LangVersion>7.3</LangVersion>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|AnyCPU'">
+    <DebugSymbols>true</DebugSymbols>
+    <OutputPath>bin\x64\Release\</OutputPath>
+    <PlatformTarget>x64</PlatformTarget>
+    <LangVersion>7.3</LangVersion>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|x64'">
+    <DebugSymbols>true</DebugSymbols>
+    <OutputPath>bin\x64\Release\</OutputPath>
+    <PlatformTarget>x64</PlatformTarget>
+    <LangVersion>7.3</LangVersion>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="Castle.Core">
+      <HintPath>..\..\DataPRO\packages\Castle.Core.4.4.0\lib\net45\Castle.Core.dll</HintPath>
+    </Reference>
+    <Reference Include="NSubstitute">
+      <HintPath>..\..\DataPRO\packages\NSubstitute.4.2.1\lib\net46\NSubstitute.dll</HintPath>
+    </Reference>
+    <Reference Include="nunit.framework">
+      <HintPath>..\..\DataPRO\packages\NUnit.3.12.0\lib\net45\nunit.framework.dll</HintPath>
+    </Reference>
+    <Reference Include="NUnit3.TestAdapter, Version=3.13.0.0, Culture=neutral, PublicKeyToken=4cb40d35494691ac, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\DataPRO\packages\NUnit3TestAdapter.3.14.0\build\net35\NUnit3.TestAdapter.dll</HintPath>
+    </Reference>
+    <Reference Include="System" />
+    <Reference Include="System.Core" />
+    <Reference Include="System.Runtime.CompilerServices.Unsafe">
+      <HintPath>..\..\DataPRO\packages\System.Runtime.CompilerServices.Unsafe.4.5.2\lib\netstandard2.0\System.Runtime.CompilerServices.Unsafe.dll</HintPath>
+    </Reference>
+    <Reference Include="System.Threading.Tasks.Extensions">
+      <HintPath>..\..\DataPRO\packages\System.Threading.Tasks.Extensions.4.5.3\lib\netstandard2.0\System.Threading.Tasks.Extensions.dll</HintPath>
+    </Reference>
+    <Reference Include="System.Xml.Linq" />
+    <Reference Include="System.Data.DataSetExtensions" />
+    <Reference Include="Microsoft.CSharp" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Net.Http" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="ChannelTypeUtilityShould.cs" />
+    <Compile Include="FilterClassShould.cs" />
+    <Compile Include="GroupChannelShould.cs" />
+    <Compile Include="LinearizationFormulaShould.cs" />
+    <Compile Include="NetworkUtilsShould.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\..\Common\DTS.Common\DTS.Common.csproj">
+      <Project>{f7a0804f-61a4-40ae-83d0-f1137622b592}</Project>
+      <Name>DTS.Common</Name>
+    </ProjectReference>
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+</Project>

Common/DTS.Common.Tests/FilterClassShould.cs

@@ -0,0 +1,355 @@
+using DTS.Common.Classes.Sensors;
+using DTS.Common.Enums.Sensors;
+using DTS.Common.Interface.Sensors;
+using NSubstitute;
+using NUnit.Framework;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+
+namespace DTS.Common.Classes.Sensors
+{
+    [TestFixture]
+    class FilterClassShould
+    {
+        List<ISoftwareFilter> softwareFilters = null;
+
+        [SetUp]
+        public void SetUp()
+        {
+            //Arrange 
+            ISoftwareFilter softwareFilter0 = Substitute.For<ISoftwareFilter>();
+            softwareFilter0.ISOCode.Returns('0');
+            softwareFilter0.Frequency.Returns(0.0);
+
+            ISoftwareFilter softwareFilterP = Substitute.For<ISoftwareFilter>();
+            softwareFilterP.ISOCode.Returns('P');
+            softwareFilterP.Frequency.Returns(0.0);
+
+
+            ISoftwareFilter softwareFilterQ = Substitute.For<ISoftwareFilter>();
+            softwareFilterQ.ISOCode.Returns('Q');
+            softwareFilterQ.Frequency.Returns(17.0);
+
+
+            ISoftwareFilter softwareFilterD = Substitute.For<ISoftwareFilter>();
+            softwareFilterD.ISOCode.Returns('D');
+            softwareFilterD.Frequency.Returns(100.00);
+
+
+            ISoftwareFilter softwareFilterC = Substitute.For<ISoftwareFilter>();
+            softwareFilterC.ISOCode.Returns('C');
+            softwareFilterC.Frequency.Returns(300.0);
+
+
+            ISoftwareFilter softwareFilterB = Substitute.For<ISoftwareFilter>();
+            softwareFilterB.ISOCode.Returns('B');
+            softwareFilterB.Frequency.Returns(1000.0);
+
+
+            ISoftwareFilter softwareFilterA = Substitute.For<ISoftwareFilter>();
+            softwareFilterA.ISOCode.Returns('A');
+            softwareFilterA.Frequency.Returns(1650.0);
+
+
+            ISoftwareFilter softwareFilterSFirst = Substitute.For<ISoftwareFilter>();
+            softwareFilterSFirst.ISOCode.Returns('S');
+            softwareFilterSFirst.Frequency.Returns(1700.0);
+
+
+            ISoftwareFilter softwareFilterSSecond = Substitute.For<ISoftwareFilter>();
+            softwareFilterSSecond.ISOCode.Returns('S');
+            softwareFilterSSecond.Frequency.Returns(1750.0);
+
+            softwareFilters = new List<ISoftwareFilter>();
+            softwareFilters.Add(softwareFilter0);
+            softwareFilters.Add(softwareFilterP);
+            softwareFilters.Add(softwareFilterQ);
+            softwareFilters.Add(softwareFilterD);
+            softwareFilters.Add(softwareFilterC);
+            softwareFilters.Add(softwareFilterB);
+            softwareFilters.Add(softwareFilterA);
+            softwareFilters.Add(softwareFilterSFirst);
+            softwareFilters.Add(softwareFilterSSecond);
+        }
+
+        [TearDown]
+        public void TearDown()
+        {
+            softwareFilters = null;
+        }
+
+        [Test]
+        public void GetFilterClassFromString_ShouldReturnUnfiltered_WhenNull()
+        {
+            //Act & Assert
+            var result = FilterClass.GetFilterClassFromString(null);
+            Assert.That(result.FClass, Is.EqualTo(FilterClassType.Unfiltered));
+        }
+
+        [Test]
+        public void GetFilterClassFromString_ShouldReturnUnfiltered_WhenEmpty()
+        {
+            //Act & Assert
+            var result = FilterClass.GetFilterClassFromString("");
+            Assert.That(result.FClass, Is.EqualTo(FilterClassType.Unfiltered));
+        }
+
+        [Test]
+        public void GetFilterClassFromString_ShouldReturnAdhoc_WhenCustom()
+        {
+            //Act & Assert
+            var result = FilterClass.GetFilterClassFromString("1700");
+            Assert.That(result.FClass, Is.EqualTo(FilterClassType.AdHoc));
+            Assert.That(result.Frequency, Is.EqualTo(1700));
+        }
+
+        [Test]
+        public void GetFilterClassFromString_ShouldReturnAdhoc_WhenCustomHz()
+        {
+            //Act & Assert
+            var result = FilterClass.GetFilterClassFromString("1700Hz");
+            Assert.That(result.FClass, Is.EqualTo(FilterClassType.AdHoc));
+            Assert.That(result.Frequency, Is.EqualTo(1700));
+        }
+        [Test]
+        public void GetFilterClassFromString_ShouldReturnCFC10_When10()
+        {
+            //Act & Assert
+            var result = FilterClass.GetFilterClassFromString("10");
+            Assert.That(result.FClass, Is.EqualTo(FilterClassType.CFC10));
+            Assert.That(result.Frequency, Is.EqualTo(17));
+        }
+        [Test]
+        public void GetFilterClassFromString_ShouldReturnCFC10_WhenCFC10()
+        {
+            //Act & Assert
+            var result = FilterClass.GetFilterClassFromString("CFC 10");
+            Assert.That(result.FClass, Is.EqualTo(FilterClassType.CFC10));
+            Assert.That(result.Frequency, Is.EqualTo(17));
+        }
+
+        [Test]
+        public void GetFilterClassFromString_ShouldReturnCFC1000_When1000()
+        {
+            //Act & Assert
+            var result = FilterClass.GetFilterClassFromString("1000");
+            Assert.That(result.FClass, Is.EqualTo(FilterClassType.CFC1000));
+            Assert.That(result.Frequency, Is.EqualTo(1650));
+        }
+        [Test]
+        public void GetFilterClassFromString_ShouldReturnCFC1000_WhenCFC1000()
+        {
+            //Act & Assert
+            var result = FilterClass.GetFilterClassFromString("CFC 1000");
+            Assert.That(result.FClass, Is.EqualTo(FilterClassType.CFC1000));
+            Assert.That(result.Frequency, Is.EqualTo(1650));
+        }
+
+        [Test]
+        public void GetFilterClassFromString_ShouldReturnCFC180_When180()
+        {
+            //Act & Assert
+            var result = FilterClass.GetFilterClassFromString("180");
+            Assert.That(result.FClass, Is.EqualTo(FilterClassType.CFC180));
+            Assert.That(result.Frequency, Is.EqualTo(300));
+        }
+        [Test]
+        public void GetFilterClassFromString_ShouldReturnCFC180_WhenCFC180()
+        {
+            //Act & Assert
+            var result = FilterClass.GetFilterClassFromString("CFC 180");
+            Assert.That(result.FClass, Is.EqualTo(FilterClassType.CFC180));
+            Assert.That(result.Frequency, Is.EqualTo(300));
+        }
+
+        [Test]
+        public void GetFilterClassFromString_ShouldReturnCFC60_When60()
+        {
+            //Act & Assert
+            var result = FilterClass.GetFilterClassFromString("60");
+            Assert.That(result.FClass, Is.EqualTo(FilterClassType.CFC60));
+            Assert.That(result.Frequency, Is.EqualTo(100));
+        }
+        [Test]
+        public void GetFilterClassFromString_ShouldReturnCFC60_WhenCFC60()
+        {
+            //Act & Assert
+            var result = FilterClass.GetFilterClassFromString("CFC 60");
+            Assert.That(result.FClass, Is.EqualTo(FilterClassType.CFC60));
+            Assert.That(result.Frequency, Is.EqualTo(100));
+        }
+
+        [Test]
+        public void GetFilterClassFromString_ShouldReturnCFC600_When600()
+        {
+            //Act & Assert
+            var result = FilterClass.GetFilterClassFromString("600");
+            Assert.That(result.FClass, Is.EqualTo(FilterClassType.CFC600));
+            Assert.That(result.Frequency, Is.EqualTo(1000));
+        }
+        [Test]
+        public void GetFilterClassFromString_ShouldReturnCFC600_WhenCFC600()
+        {
+            //Act & Assert
+            var result = FilterClass.GetFilterClassFromString("CFC 600");
+            Assert.That(result.FClass, Is.EqualTo(FilterClassType.CFC600));
+            Assert.That(result.Frequency, Is.EqualTo(1000));
+        }
+
+        [Test]
+        public void GetFilterClassFromString_ShouldReturnUnfiltered_WhenInvalidInput()
+        {
+            //Act & Assert
+            var result = FilterClass.GetFilterClassFromString("fg342");
+            Assert.That(result.FClass, Is.EqualTo(FilterClassType.Unfiltered));
+        }
+
+        [Test]
+        public void GetFilterClassFromString_ShouldReturnNone_WhenNone()
+        {
+            //Act & Assert
+            var result = FilterClass.GetFilterClassFromString("None");
+            Assert.That(result.FClass, Is.EqualTo(FilterClassType.None));
+        }
+
+
+        [Test]
+        public void GetDefaultFilterClass_ShouldReturnUnfiltered_When0()
+        {
+            //Arrange
+            softwareFilters.Find(p => p.ISOCode == '0').IsDefault.Returns(true);
+
+            //Act & Assert
+            var result = FilterClass.GetDefaultFilterClass(softwareFilters);
+            Assert.That(result.FClass, Is.EqualTo(FilterClassType.Unfiltered));
+        }
+
+        [Test]
+        public void GetDefaultFilterClass_ShouldReturnNone_WhenP()
+        {
+            //Arrange
+            softwareFilters.Find(p => p.ISOCode == 'P').IsDefault.Returns(true);
+
+            //Act & Assert
+            var result = FilterClass.GetDefaultFilterClass(softwareFilters);
+            Assert.That(result.FClass, Is.EqualTo(FilterClassType.None));
+        }
+
+        [Test]
+        public void GetDefaultFilterClass_ShouldReturnCFC1000_WhenA()
+        {
+            //Arrange
+            softwareFilters.Find(p => p.ISOCode == 'A').IsDefault.Returns(true);
+
+            //Act & Assert
+            var result = FilterClass.GetDefaultFilterClass(softwareFilters);
+            Assert.That(result.FClass, Is.EqualTo(FilterClassType.CFC1000));
+        }
+
+        [Test]
+        public void GetDefaultFilterClass_ShouldReturnCFC600_WhenB()
+        {
+            //Arrange
+            softwareFilters.Find(p => p.ISOCode == 'B').IsDefault.Returns(true);
+
+            //Act & Assert
+            var result = FilterClass.GetDefaultFilterClass(softwareFilters);
+            Assert.That(result.FClass, Is.EqualTo(FilterClassType.CFC600));
+        }
+
+        [Test]
+        public void GetDefaultFilterClass_ShouldReturnCFC600_WhenC()
+        {
+            //Arrange
+            softwareFilters.Find(p => p.ISOCode == 'C').IsDefault.Returns(true);
+
+            //Act & Assert
+            var result = FilterClass.GetDefaultFilterClass(softwareFilters);
+            Assert.That(result.FClass, Is.EqualTo(FilterClassType.CFC180));
+        }
+
+        [Test]
+        public void GetDefaultFilterClass_ShouldReturnCFC600_WhenD()
+        {
+            //Arrange
+            softwareFilters.Find(p => p.ISOCode == 'D').IsDefault.Returns(true);
+
+            //Act & Assert
+            var result = FilterClass.GetDefaultFilterClass(softwareFilters);
+            Assert.That(result.FClass, Is.EqualTo(FilterClassType.CFC60));
+        }
+
+        [Test]
+        public void GetDefaultFilterClass_ShouldReturnAdhoc1700_WhenSAnd1700()
+        {
+            //Arrange
+            softwareFilters.Find(p => p.ISOCode == 'S' && p.Frequency == 1700.00).IsDefault.Returns(true);
+
+            //Act & Assert
+            var result = FilterClass.GetDefaultFilterClass(softwareFilters);
+            Assert.That(result.FClass, Is.EqualTo(FilterClassType.AdHoc));
+            Assert.That(result.Frequency, Is.EqualTo(1700.00));
+        }
+
+        [Test]
+        public void GetDefaultFilterClass_ShouldReturnCFC1000_WhenNull()
+        {
+            //Arrange
+            softwareFilters = null;
+
+            //Act & Assert
+            var result = FilterClass.GetDefaultFilterClass(softwareFilters);
+            Assert.That(result.FClass, Is.EqualTo(FilterClassType.CFC1000));
+        }
+
+        [Test]
+        public void GetDefaultFilterClass_ShouldReturnCFC1000_WhenEmptyCollection()
+        {
+            //Arrange
+            softwareFilters = new List<ISoftwareFilter>();
+
+            //Act & Assert
+            var result = FilterClass.GetDefaultFilterClass(softwareFilters);
+            Assert.That(result.FClass, Is.EqualTo(FilterClassType.CFC1000));
+        }
+
+
+        [Test]
+        public void GetFrequencyFromFilterClassType_ShouldReturn1650_WhenCFC1000()
+        {
+            //Act & Assert
+            var result = FilterClass.GetFrequencyFromFilterClassType(FilterClassType.CFC1000);
+            Assert.That(result, Is.EqualTo(1650));
+        }
+
+        [Test]
+        public void GetFrequencyFromFilterClassType_ShouldReturn0_WhenNone()
+        {
+            //Act & Assert
+            var result = FilterClass.GetFrequencyFromFilterClassType(FilterClassType.None);
+            Assert.That(result, Is.EqualTo(0));
+        }
+
+        [Test]
+        public void GetFrequencyFromFilterClassType_ShouldReturnMinus2_WhenUnfiltered()
+        {
+            //Act & Assert
+            var result = FilterClass.GetFrequencyFromFilterClassType(FilterClassType.Unfiltered);
+            Assert.That(result, Is.EqualTo(-2));
+        }
+
+        [Test]
+        public void GetFrequencyFromFilterClassType_ShouldThrowException_WhenAdHoc()
+        {
+            //Act & Assert
+            Assert.That(
+              () => FilterClass.GetFrequencyFromFilterClassType(FilterClassType.AdHoc)
+               , Throws.TypeOf<Exception>()
+          .With
+          .Property("Message")
+          .EqualTo("GetFrequencyFromFilterClassType: AdHoc FilterClassType does not have frequency associated"));
+        }
+    }
+}

Common/DTS.Common.Tests/GroupChannelShould.cs

@@ -0,0 +1,254 @@
+using DTS.Common.Enums.Sensors;
+using DTS.Common.Interface.Channels;
+using DTS.Common.Interface.Groups.GroupList;
+using DTS.Common.Interface.Sensors;
+
+using NSubstitute;
+using NUnit.Framework;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace DTS.Common.Classes.Groups
+{
+    [TestFixture]
+    class GroupChannelShould
+    {
+
+        [Test]
+        public void GetFilterClassFromISOCode_ShouldReturnCFC1000WhenIsoIsA()
+        {
+            //Arrange
+            ISoftwareFilter sf1 = Substitute.For<ISoftwareFilter>();
+            ISoftwareFilter sf2 = Substitute.For<ISoftwareFilter>();
+            List<ISoftwareFilter> filters = new List<ISoftwareFilter>();
+            filters.Add(sf1);
+            filters.Add(sf2);
+
+            IGroup group = Substitute.For<IGroup>();
+
+            IChannelSetting chs1 = Substitute.For<IChannelSetting>();
+            chs1.SettingName.Returns("FilterClass");
+            List<IChannelSetting> channelSettings = new List<IChannelSetting>();
+            channelSettings.Add(chs1);
+            IGroupChannel groupChannel = new GroupChannel(false, "TestGroup", group, channelSettings.ToArray());
+
+            //Act
+            var result = groupChannel.GetFilterClassFromISOCode(filters.ToArray(), "???????????????A");
+
+            //Assert 
+            Assert.That(result.FClass, Is.EqualTo(FilterClassType.CFC1000));
+        }
+
+        [Test]
+        public void GetFilterClassFromISOCode_ShouldReturnCFC600WhenIsoIsB()
+        {
+            //Arrange
+            ISoftwareFilter sf1 = Substitute.For<ISoftwareFilter>();
+            ISoftwareFilter sf2 = Substitute.For<ISoftwareFilter>();
+            List<ISoftwareFilter> filters = new List<ISoftwareFilter>();
+            filters.Add(sf1);
+            filters.Add(sf2);
+
+            IGroup group = Substitute.For<IGroup>();
+
+            IChannelSetting chs1 = Substitute.For<IChannelSetting>();
+            chs1.SettingName.Returns("FilterClass");
+            List<IChannelSetting> channelSettings = new List<IChannelSetting>();
+            channelSettings.Add(chs1);
+            IGroupChannel groupChannel = new GroupChannel(false, "TestGroup", group, channelSettings.ToArray());
+
+            //Act
+            var result = groupChannel.GetFilterClassFromISOCode(filters.ToArray(), "???????????????B");
+
+            //Assert 
+            Assert.That(result.FClass, Is.EqualTo(FilterClassType.CFC600));
+        }
+
+        [Test]
+        public void GetFilterClassFromISOCode_ShouldReturnCFC180WhenIsoIsC()
+        {
+            //Arrange
+            ISoftwareFilter sf1 = Substitute.For<ISoftwareFilter>();
+            ISoftwareFilter sf2 = Substitute.For<ISoftwareFilter>();
+            List<ISoftwareFilter> filters = new List<ISoftwareFilter>();
+            filters.Add(sf1);
+            filters.Add(sf2);
+
+            IGroup group = Substitute.For<IGroup>();
+
+            IChannelSetting chs1 = Substitute.For<IChannelSetting>();
+            chs1.SettingName.Returns("FilterClass");
+            List<IChannelSetting> channelSettings = new List<IChannelSetting>();
+            channelSettings.Add(chs1);
+            IGroupChannel groupChannel = new GroupChannel(false, "TestGroup", group, channelSettings.ToArray());
+
+            //Act
+            var result = groupChannel.GetFilterClassFromISOCode(filters.ToArray(), "???????????????C");
+
+            //Assert 
+            Assert.That(result.FClass, Is.EqualTo(FilterClassType.CFC180));
+        }
+
+        [Test]
+        public void GetFilterClassFromISOCode_ShouldReturnCFC60WhenIsoIsD()
+        {
+            //Arrange
+            ISoftwareFilter sf1 = Substitute.For<ISoftwareFilter>();
+            ISoftwareFilter sf2 = Substitute.For<ISoftwareFilter>();
+            List<ISoftwareFilter> filters = new List<ISoftwareFilter>();
+            filters.Add(sf1);
+            filters.Add(sf2);
+
+            IGroup group = Substitute.For<IGroup>();
+
+            IChannelSetting chs1 = Substitute.For<IChannelSetting>();
+            chs1.SettingName.Returns("FilterClass");
+            List<IChannelSetting> channelSettings = new List<IChannelSetting>();
+            channelSettings.Add(chs1);
+            IGroupChannel groupChannel = new GroupChannel(false, "TestGroup", group, channelSettings.ToArray());
+
+            //Act
+            var result = groupChannel.GetFilterClassFromISOCode(filters.ToArray(), "???????????????D");
+
+            //Assert 
+            Assert.That(result.FClass, Is.EqualTo(FilterClassType.CFC60));
+        }
+
+        [Test]
+        public void GetFilterClassFromISOCode_ShouldReturnUnfilteredWhenIsoIs0()
+        {
+            //Arrange
+            ISoftwareFilter sf1 = Substitute.For<ISoftwareFilter>();
+            ISoftwareFilter sf2 = Substitute.For<ISoftwareFilter>();
+            List<ISoftwareFilter> filters = new List<ISoftwareFilter>();
+            filters.Add(sf1);
+            filters.Add(sf2);
+
+            IGroup group = Substitute.For<IGroup>();
+
+            IChannelSetting chs1 = Substitute.For<IChannelSetting>();
+            chs1.SettingName.Returns("FilterClass");
+            List<IChannelSetting> channelSettings = new List<IChannelSetting>();
+            channelSettings.Add(chs1);
+            IGroupChannel groupChannel = new GroupChannel(false, "TestGroup", group, channelSettings.ToArray());
+
+            //Act
+            var result = groupChannel.GetFilterClassFromISOCode(filters.ToArray(), "???????????????0");
+
+            //Assert 
+            Assert.That(result.FClass, Is.EqualTo(FilterClassType.Unfiltered));
+        }
+
+        public void GetFilterClassFromISOCode_ShouldReturnNoneWhenIsoIsP()
+        {
+            //Arrange
+            ISoftwareFilter sf1 = Substitute.For<ISoftwareFilter>();
+            ISoftwareFilter sf2 = Substitute.For<ISoftwareFilter>();
+            List<ISoftwareFilter> filters = new List<ISoftwareFilter>();
+            filters.Add(sf1);
+            filters.Add(sf2);
+
+            IGroup group = Substitute.For<IGroup>();
+
+            IChannelSetting chs1 = Substitute.For<IChannelSetting>();
+            chs1.SettingName.Returns("FilterClass");
+            List<IChannelSetting> channelSettings = new List<IChannelSetting>();
+            channelSettings.Add(chs1);
+            IGroupChannel groupChannel = new GroupChannel(false, "TestGroup", group, channelSettings.ToArray());
+
+            //Act
+            var result = groupChannel.GetFilterClassFromISOCode(filters.ToArray(), "???????????????P");
+
+            //Assert 
+            Assert.That(result.FClass, Is.EqualTo(FilterClassType.None));
+        }
+
+        [Test]
+        public void GetFilterClassFromISOCode_ShouldReturnAdhocWhenIsoIsAdhoc1800()
+        {
+            //Arrange
+            ISoftwareFilter sf1 = Substitute.For<ISoftwareFilter>();
+            ISoftwareFilter sf2 = Substitute.For<ISoftwareFilter>();
+            sf1.Frequency.Returns(1800);
+            sf1.ISOCode.Returns('S');
+
+            List<ISoftwareFilter> filters = new List<ISoftwareFilter>();
+            filters.Add(sf1);
+            filters.Add(sf2);
+
+            IGroup group = Substitute.For<IGroup>();
+
+            IChannelSetting chs1 = Substitute.For<IChannelSetting>();
+            chs1.SettingName.Returns("FilterClass");
+            List<IChannelSetting> channelSettings = new List<IChannelSetting>();
+            channelSettings.Add(chs1);
+            IGroupChannel groupChannel = new GroupChannel(false, "TestGroup", group, channelSettings.ToArray());
+
+            //Act
+            var result = groupChannel.GetFilterClassFromISOCode(filters.ToArray(), "???????????????S");
+
+            //Assert 
+            Assert.That(result.FClass, Is.EqualTo(FilterClassType.AdHoc));
+            Assert.That(result.Frequency, Is.EqualTo(1800));
+        }
+
+        [Test]
+        public void GetFilterClassFromISOCode_ShouldReturnCFC1000WhenNoAdhocFilter()
+        {
+            //Arrange
+            ISoftwareFilter sf1 = Substitute.For<ISoftwareFilter>();
+            ISoftwareFilter sf2 = Substitute.For<ISoftwareFilter>();
+            sf1.Frequency.Returns(1650);
+            sf1.ISOCode.Returns('A');
+
+            List<ISoftwareFilter> filters = new List<ISoftwareFilter>();
+            filters.Add(sf1);
+            filters.Add(sf2);
+
+            IGroup group = Substitute.For<IGroup>();
+
+            IChannelSetting chs1 = Substitute.For<IChannelSetting>();
+            chs1.SettingName.Returns("FilterClass");
+            List<IChannelSetting> channelSettings = new List<IChannelSetting>();
+            channelSettings.Add(chs1);
+            IGroupChannel groupChannel = new GroupChannel(false, "TestGroup", group, channelSettings.ToArray());
+
+            //Act
+            var result = groupChannel.GetFilterClassFromISOCode(filters.ToArray(), "???????????????S");
+
+            //Assert 
+            Assert.That(result.FClass, Is.EqualTo(FilterClassType.CFC1000));
+
+        }
+
+        [Test]
+        public void GetFilterClassFromISOCode_ShouldReturnCFC1000WhenIsoIsNotValid()
+        {
+            //Arrange
+            ISoftwareFilter sf1 = Substitute.For<ISoftwareFilter>();
+            ISoftwareFilter sf2 = Substitute.For<ISoftwareFilter>();
+            List<ISoftwareFilter> filters = new List<ISoftwareFilter>();
+            filters.Add(sf1);
+            filters.Add(sf2);
+
+            IGroup group = Substitute.For<IGroup>();
+
+            IChannelSetting chs1 = Substitute.For<IChannelSetting>();
+            chs1.SettingName.Returns("FilterClass");
+            List<IChannelSetting> channelSettings = new List<IChannelSetting>();
+            channelSettings.Add(chs1);
+            IGroupChannel groupChannel = new GroupChannel(false, "TestGroup", group, channelSettings.ToArray());
+
+            //Act
+            var result = groupChannel.GetFilterClassFromISOCode(filters.ToArray(), "???????????????H");
+
+            //Assert 
+            Assert.That(result.FClass, Is.EqualTo(FilterClassType.CFC1000));
+        }
+
+
+    }
+}

Common/DTS.Common.Tests/LinearizationFormulaShould.cs

@@ -0,0 +1,79 @@
+using DTS.Common.Classes.Sensors;
+using DTS.Common.Utils;
+using NUnit.Framework;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace DTS.Common.Tests
+{
+    public class LinearizationFormulaShould
+    {
+        [Test]
+        public void GetLinearizedValue_ShouldReturnCorrectEU_OnNonLinearAndNonProportional()
+        {
+            //Arrange
+            LinearizationFormula linearizationFormula = new LinearizationFormula();
+            linearizationFormula.PolynomialCoefficients = new double[] { 1657.882, 4368.774, 204.5695, 24.8535 };
+            //Act
+            //Assert 
+            var resultEU = linearizationFormula.GetLinearizedValue(-0.39272, 5, false);
+            Assert.That(resultEU, Is.EqualTo(-27.7773).Within(.0005));
+
+            var resultEU2 = linearizationFormula.GetLinearizedValue(-0.14947, 5, false);
+            Assert.That(resultEU2, Is.EqualTo(1009.369).Within(.0005));
+
+            var resultEU3 = linearizationFormula.GetLinearizedValue(0.73579, 5, false);
+            Assert.That(resultEU3, Is.EqualTo(4993.034).Within(.0005));
+
+            var resultEU4 = linearizationFormula.GetLinearizedValue(0.30645, 5, false);
+            Assert.That(resultEU4, Is.EqualTo(3016.62).Within(.0005));
+
+        }
+        [Test]
+        public void GetLinearizedValue_ShouldReturnCorrectEU_OnNonLinearAndProportional()
+        {
+            //Arrange
+            LinearizationFormula linearizationFormula = new LinearizationFormula();
+            linearizationFormula.PolynomialCoefficients = new double[] { 1657.882, 4368.774, 204.5695, 24.8535 };
+            //Act
+            //Assert 
+            var resultEU = linearizationFormula.GetLinearizedValue(-0.39272, 5, true);
+            Assert.That(resultEU, Is.Not.EqualTo(-27.7773).Within(.0005));
+            var resultEU2 = linearizationFormula.GetLinearizedValue(-0.14947, 5, true);
+            Assert.That(resultEU2, Is.Not.EqualTo(1009.369).Within(.0005));
+
+        }
+
+        [Test]
+        public void GetLinearizedValue_ShouldReturnCorrectEU_OnNonLinearAndProportionalSpecifiedAsNull()
+        {
+            //Arrange
+            LinearizationFormula linearizationFormula = new LinearizationFormula();
+            linearizationFormula.PolynomialCoefficients = new double[] { 1657.882, 4368.774, 204.5695, 24.8535 };
+            //Act
+            //Assert 
+            var resultEU = linearizationFormula.GetLinearizedValue(-0.39272, 5, null);
+            Assert.That(resultEU, Is.Not.EqualTo(-27.7773).Within(.0005));
+            var resultEU2 = linearizationFormula.GetLinearizedValue(-0.14947, 5, null);
+            Assert.That(resultEU2, Is.Not.EqualTo(1009.369).Within(.0005));
+
+        }
+
+        [Test]
+        public void GetLinearizedValue_ShouldNonLinearStyleBePolynomial_ByDefault()
+        {
+            //Arrange
+            LinearizationFormula linearizationFormula = new LinearizationFormula();
+            linearizationFormula.PolynomialCoefficients = new double[] { 1657.882, 4368.774, 204.5695, 24.8535 };
+
+            //Act
+            //Assert 
+            Assert.That(linearizationFormula.NonLinearStyle, Is.EqualTo(Enums.Sensors.NonLinearStyles.Polynomial));
+
+        }
+
+    }
+}

Common/DTS.Common.Tests/NetworkUtilsShould.cs

@@ -0,0 +1,99 @@
+using DTS.Common.Utils;
+using NUnit.Framework;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace DTS.Common.Tests
+{
+    [TestFixture]
+    class NetworkUtilsShould
+    {
+        [Test]
+        public void TryParseConnectionString_ShouldReturnFalseWhenConnectionStringIsNull()
+        {
+            //Arrange
+
+            //Act
+            var result = NetworkUtils.TryParseConnectionString(null, out _);
+
+            //Assert 
+            Assert.That(result, Is.False);
+        }
+
+        [Test]
+        public void TryParseConnectionString_ShouldReturnFalseWhenConnectionStringDoesNotContainIp()
+        {
+            //Arrange
+            var connectionString = @"\\?\usb#vid_1cb9&pid_001b#6&284bed14&2&1#{fb10e3ff-ece3-410e-beeb-719096813fb9}";
+            //Act
+            var result = NetworkUtils.TryParseConnectionString(connectionString, out _);
+
+            //Assert 
+            Assert.That(result, Is.False);
+        }
+
+        [Test]
+        public void TryParseConnectionString_ShouldReturnTrueWhenConnectionStringContainsIpAndPort()
+        {
+            //Arrange
+            var connectionString = @"192.168.1.61:8083";
+            string ipAddress;
+
+            //Act
+            var result = NetworkUtils.TryParseConnectionString(connectionString, out ipAddress);
+
+            //Assert 
+            Assert.That(result, Is.True);
+            Assert.That(ipAddress, Is.EqualTo("192.168.1.61"));
+        }
+
+
+        [Test]
+        public void TryParseConnectionString_ShouldReturnTrueWhenConnectionStringContainsOnlyIp()
+        {
+            //Arrange
+            var connectionString = @"192.168.1.61";
+            string ipAddress;
+
+            //Act
+            var result = NetworkUtils.TryParseConnectionString(connectionString, out ipAddress);
+
+            //Assert 
+            Assert.That(result, Is.True);
+            Assert.That(ipAddress, Is.EqualTo("192.168.1.61"));
+        }
+
+        [Test]
+        public void TryParseConnectionString_ShouldReturnTrueWhenConnectionStringContainsOnlyIpWithProtocolUDP()
+        {
+            //Arrange
+            var connectionString = @"udp://192.168.1.10:8200 ";
+            string ipAddress;
+
+            //Act
+            var result = NetworkUtils.TryParseConnectionString(connectionString, out ipAddress);
+
+            //Assert 
+            Assert.That(result, Is.True);
+            Assert.That(ipAddress, Is.EqualTo("192.168.1.10"));
+        }
+
+        [Test]
+        public void TryParseConnectionString_ShouldReturnTrueWhenConnectionStringContainsOnlyIpWithProtocolHTTP()
+        {
+            //Arrange
+            var connectionString = @"http://192.168.1.10:8200 ";
+            string ipAddress;
+
+            //Act
+            var result = NetworkUtils.TryParseConnectionString(connectionString, out ipAddress);
+
+            //Assert 
+            Assert.That(result, Is.True);
+            Assert.That(ipAddress, Is.EqualTo("192.168.1.10"));
+        }
+    }
+}

Common/DTS.Common.Tests/Properties/AssemblyInfo.cs

@@ -0,0 +1,36 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("DTS.Common.Tests")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("DTS.Common.Tests")]
+[assembly: AssemblyCopyright("Copyright ©  2020")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible
+// to COM components.  If you need to access a type in this assembly from
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("4ce21bec-2c24-4e62-bd33-f689016f331d")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Build and Revision Numbers
+// by using the '*' as shown below:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]

Common/DTS.Common.Tests/obj/Debug/.NETFramework,Version=v4.8.AssemblyAttributes.cs

@@ -0,0 +1,4 @@
+// <autogenerated />
+using System;
+using System.Reflection;
+[assembly: global::System.Runtime.Versioning.TargetFrameworkAttribute(".NETFramework,Version=v4.8", FrameworkDisplayName = "")]