public void CTOR_DD_Test()
        {
            var     mvcm  = new MunichCoordinatesModel();
            decimal ddLat = mvcm.DegreesLat;
            decimal ddLon = mvcm.DegreesLon;

            var dd = new DDCoordinate(ddLat, ddLon);

            string expectedResult = MunichCoordinatesModel.StrDDM();
            string actualResult   = dd.ToString();

            decimal latDiff = Math.Abs(dd.GetLattitudeDD() - mvcm.DegreesLat);
            decimal lonDiff = Math.Abs(dd.GetLongitudeDD() - mvcm.DegreesLon);

            var dict = new Dictionary <string, decimal>
            {
                { "latDiff", latDiff },
                { "lonDiff", lonDiff }
            };

            DisplayOutput(expectedResult, actualResult, dict);

            Assert.IsTrue(latDiff >= 0 && latDiff <= DegreeAccuracyThreshold);
            Assert.IsTrue(lonDiff >= 0 && lonDiff <= DegreeAccuracyThreshold);
        }
        public void DmsToDDM_NE_Test()
        {
            var mcm = new MunichCoordinatesModel();
            var ddm = new DDMCoordinate(
                mcm.ShortDegreesLattitude(), mcm.DdmMinsLat, mcm.DmsSecondsLat,
                mcm.ShortDegreesLongitude(), mcm.DdmMinsLon, mcm.DmsSecondsLon
                );
            string expectedResult = MunichCoordinatesModel.StrDDM();
            int    expectedLength = expectedResult.Length;

            string actualResult = ddm.ToString();
            int    actualLength = actualResult.Length;

            decimal latDiff = Math.Abs(ddm.GetShortDegreesLat() - Math.Truncate(mcm.DegreesLat));
            decimal lonDiff = Math.Abs(ddm.GetShortDegreesLon() - Math.Truncate(mcm.DegreesLon));

            decimal latMinsDiff = Math.Abs(ddm.GetMinsLat() - mcm.DdmMinsLat);
            decimal lonMinsDiff = Math.Abs(ddm.GetMinsLon() - mcm.DdmMinsLon);

            var dict = new Dictionary <string, decimal>
            {
                { "latDiff", latDiff },
                { "lonDiff", lonDiff },
                { "latMinsDiff", latMinsDiff },
                { "lonMinsDiff", lonMinsDiff }
            };

            DisplayOutput(expectedResult, actualResult, dict);

            Assert.AreEqual(expectedLength, actualLength);
            Assert.IsTrue(latDiff >= 0 && latDiff <= DegreeAccuracyThreshold);
            Assert.IsTrue(latMinsDiff >= 0 && latMinsDiff <= LatMinsAccuracyThreshold);
            Assert.IsTrue(lonDiff >= 0 && lonDiff <= DegreeAccuracyThreshold);
            Assert.IsTrue(lonMinsDiff >= 0 && lonMinsDiff <= LonMinsAccuracyThreshold);
        }
        public void ExtractPolarityEWTest()
        {
            int expectedPositiveResult = 1;
            int expectedNegativeResult = -1;
            int expectedZeroResult     = 0;

            short actualPositiveResult = ConversionHelper.ExtractPolarityEW(MunichCoordinatesModel.StrDDM());
            short actualNegativeResult = ConversionHelper.ExtractPolarityEW(SanClementeCoordinatesModel.StrDDM());
            short actualZeroResult     = ConversionHelper.ExtractPolarityEW(string.Empty);

            Assert.AreEqual(expectedPositiveResult, actualPositiveResult);
            Assert.AreEqual(expectedNegativeResult, actualNegativeResult);
            Assert.AreEqual(expectedZeroResult, actualZeroResult);
        }