public void CTOR_DMS_Test()
{
var mcm = new MunichCoordinatesModel();
decimal latDegrees = mcm.ShortDegreesLattitude();
decimal latMinutes = Math.Truncate(mcm.DdmMinsLat);
decimal latSeconds = mcm.DmsSecondsLat;
decimal lonDegrees = mcm.ShortDegreesLongitude();
decimal lonMinutes = Math.Truncate(mcm.DdmMinsLon);
decimal lonSeconds = mcm.DmsSecondsLon;
var dd = new DDCoordinate(latDegrees, latMinutes, latSeconds, lonDegrees, lonMinutes, lonSeconds);
string expectedResult = MunichCoordinatesModel.StrDD();
string actualResult = dd.ToString();
decimal latDiff = Math.Abs(dd.GetLattitudeDD() - mcm.DegreesLat);
decimal lonDiff = Math.Abs(dd.GetLongitudeDD() - mcm.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 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 DmsToDD_NE_Test()
{
var mcm = new MunichCoordinatesModel();
var dd = new DDCoordinate(
mcm.ShortDegreesLattitude(), mcm.DdmMinsLat, mcm.DmsSecondsLat,
mcm.ShortDegreesLongitude(), mcm.DdmMinsLon, mcm.DmsSecondsLon
);
string expectedResult = MunichCoordinatesModel.StrDD();
int expectedLength = expectedResult.Length;
string actualResult = dd.ToString();
int actualLength = actualResult.Length;
decimal latDiff = Math.Abs(dd.GetLattitudeDD() - mcm.DegreesLat);
decimal lonDiff = Math.Abs(dd.GetLongitudeDD() - mcm.DegreesLon);
var dict = new Dictionary <string, decimal>
{
{ "latDiff", latDiff },
{ "lonDiff", lonDiff }
};
DisplayOutput(expectedResult, actualResult, dict);
Assert.AreEqual(expectedLength, actualLength);
Assert.IsTrue(latDiff >= 0 && latDiff <= DegreeAccuracyThreshold);
Assert.IsTrue(lonDiff >= 0 && lonDiff <= DegreeAccuracyThreshold);
}
public void DdToDDM_NE_Test()
{
var mcm = new MunichCoordinatesModel();
var ddm = new DDMCoordinate(
mcm.DegreesLat, mcm.DegreesLon
);
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 ConvertGridsquareToDDMTestNE()
{
var mcm = new MunichCoordinatesModel();
var cc = new GridDdmExpert();
string gridsquare = MunichCoordinatesModel.StrGridSquare();
var expectedResult = new DDMCoordinate(mcm.DegreesLat, mcm.DdmMinsLat, mcm.DegreesLon, mcm.DdmMinsLon);
DDMCoordinate actualResult = cc.ConvertGridsquareToDDM(gridsquare);
decimal latDiff = Math.Abs(expectedResult.GetShortDegreesLat() - actualResult.GetShortDegreesLat());
decimal lonDiff = Math.Abs(expectedResult.GetShortDegreesLon() - actualResult.GetShortDegreesLon());
decimal latMinsDiff = Math.Abs(expectedResult.GetMinsLat() - actualResult.GetMinsLat());
decimal lonMinsDiff = Math.Abs(expectedResult.GetMinsLon() - actualResult.GetMinsLon());
var dict = new Dictionary <string, decimal>
{
{ "latDiff", latDiff },
{ "lonDiff", lonDiff },
{ "latMinsDiff", latMinsDiff },
{ "lonMinsDiff", lonMinsDiff }
};
DisplayOutput(expectedResult.ToString(), actualResult.ToString(), dict);
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 GetFractionalLongitudeTest()
{
var mcm = new MunichCoordinatesModel();
var dd = new DDCoordinate(mcm.DegreesLat, mcm.DegreesLon);
decimal expectedResult = mcm.DegreesLon - Math.Truncate(mcm.DegreesLon);
decimal actualResult = dd.GetFractionalLongitude();
Assert.AreEqual(expectedResult, actualResult);
}
public void GetShortDegreesLatTest()
{
var mcm = new MunichCoordinatesModel();
var dd = new DDCoordinate(mcm.DegreesLat, mcm.DegreesLon);
decimal expectedResult = mcm.ShortDegreesLattitude();
decimal actualResult = dd.GetShortDegreesLat();
Assert.AreEqual(expectedResult, actualResult);
}
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);
}
public void ConvertDDMtoGridsquareTest_NE()
{
var mcm = new MunichCoordinatesModel();
decimal degreesLat = Math.Truncate(mcm.DegreesLat);
decimal degreesLon = Math.Truncate(mcm.DegreesLon);
decimal minutesLat = mcm.DdmMinsLat;
decimal minutesLon = mcm.DdmMinsLon;
var ddm = new DDMCoordinate(degreesLat, minutesLat, degreesLon, minutesLon);
var cc = new GridDdmExpert();
string expectedResult = MunichCoordinatesModel.StrGridSquare();
string actualResult = cc.ConvertDDMtoGridsquare(ddm);
Assert.AreEqual(expectedResult, actualResult);
}
public void GetNSEW2_Test1()
{
string expectedNorthResult = "N";
string expectedEastResult = "E";
string expectedNonResult = "N";
var munich = new MunichCoordinatesModel();
string actualNorthResult = ConversionHelper.GetNSEW(munich.DegreesLat, 1);
string actualEastResult = ConversionHelper.GetNSEW(munich.DegreesLon, 2);
string actualLattitudeNonResult = ConversionHelper.GetNSEW(0, 1);
Assert.AreEqual(expectedNorthResult, actualNorthResult);
Assert.AreEqual(expectedEastResult, actualEastResult);
Assert.AreEqual(expectedNonResult, actualLattitudeNonResult);
}
public void GetShortMinutesLattitudeTest()
{
var mcm = new MunichCoordinatesModel();
var dms = new DMSCoordinate(mcm.DegreesLat, mcm.DegreesLon);
decimal shortMinutesLat = dms.GetShortMinutesLattitude();
decimal minutesLatDiff = Math.Abs(Math.Truncate(mcm.DdmMinsLat) - shortMinutesLat);
var dict = new Dictionary <string, decimal>
{
{ "minutesLatDiff", minutesLatDiff }
};
DisplayOutput("49", shortMinutesLat.ToString(), dict);
Assert.IsTrue(minutesLatDiff <= 0.1m);
}
public void CTOR_DDtoDMS_NE_Test()
{
var mcm = new MunichCoordinatesModel();
decimal ddLat = mcm.DegreesLat;
decimal ddLon = mcm.DegreesLon;
var dms = new DMSCoordinate(ddLat, ddLon);
string expectedResult = LynnwoodCoordinatesModel.StrDMS();
string actualResult = dms.ToString();
decimal latDiff = Math.Abs(dms.GetShortDegreesLat() - Math.Truncate(mcm.DegreesLat));
decimal lonDiff = Math.Abs(dms.GetShortDegreesLon() - Math.Truncate(mcm.DegreesLon));
decimal latMinsDiff = Math.Abs(dms.GetShortMinutesLattitude() - Math.Truncate(mcm.DdmMinsLat));
decimal lonMinsDiff = Math.Abs(dms.GetShortMinutesLongitude() - Math.Truncate(mcm.DdmMinsLon));
decimal latSecsDiff = Math.Abs(dms.GetSecondsLattitude() - mcm.DmsSecondsLat);
decimal lonSecsDiff = Math.Abs(dms.GetSecondsLongitude() - mcm.DmsSecondsLon);
var dict = new Dictionary <string, decimal>
{
{ "latDiff", latDiff },
{ "lonDiff", lonDiff },
{ "latMinsDiff", latMinsDiff },
{ "lonMinsDiff", lonMinsDiff },
{ "latSecsDiff", latSecsDiff },
{ "lonSecsDiff", lonSecsDiff }
};
DisplayOutput(expectedResult, actualResult, dict);
Assert.IsTrue(latDiff >= 0 && latDiff <= 0.0001m);
Assert.IsTrue(latMinsDiff >= 0 && latMinsDiff <= 0.1m);
Assert.IsTrue(latSecsDiff >= 0 && latSecsDiff <= 1.0m);
Assert.IsTrue(lonDiff >= 0 && lonDiff <= 0.0001m);
Assert.IsTrue(lonMinsDiff >= 0 && lonMinsDiff <= 0.1m);
Assert.IsTrue(lonSecsDiff >= 0 && lonSecsDiff <= 1.0m);
}
