public void BaseStationMessageTranslator_Translate_Only_Translate_Status_Codes_For_Status_Messages()
{
foreach (BaseStationMessageType messageType in Enum.GetValues(typeof(BaseStationMessageType)))
{
if (messageType == BaseStationMessageType.Unknown)
{
continue;
}
foreach (BaseStationStatusCode statusCode in Enum.GetValues(typeof(BaseStationStatusCode)))
{
if (statusCode == BaseStationStatusCode.None)
{
continue;
}
string text = String.Format("{0},1,5,2056,7404F2,11267,2008/11/28,23:48:18.611,2008/11/28,23:53:19.161,{1},,,,,,,,,,,",
BaseStationMessageHelper.ConvertToString(messageType),
BaseStationMessageHelper.ConvertToString(statusCode));
string errorText = String.Format("{0} and {1}", messageType, statusCode);
BaseStationMessage message = _Implementation.Translate(text, 123);
if (messageType == BaseStationMessageType.StatusChange)
{
Assert.AreEqual(statusCode, message.StatusCode, errorText);
}
else
{
Assert.AreEqual(BaseStationMessageHelper.ConvertToString(statusCode), message.Callsign, errorText);
}
}
}
}
public void BaseStationMessageTranslator_Translate_Ignores_TransmissionType_For_All_NonTransmission_Messages()
{
foreach (BaseStationMessageType messageType in Enum.GetValues(typeof(BaseStationMessageType)))
{
if (messageType == BaseStationMessageType.Unknown)
{
continue;
}
foreach (BaseStationTransmissionType transmissionType in Enum.GetValues(typeof(BaseStationTransmissionType)))
{
if (transmissionType == BaseStationTransmissionType.None)
{
continue;
}
string text = String.Format("{0},{1},5,2056,7404F2,11267,2008/11/28,23:48:18.611,2008/11/28,23:53:19.161,,,,,,,,,,,,",
BaseStationMessageHelper.ConvertToString(messageType),
BaseStationMessageHelper.ConvertToString(transmissionType));
string errorText = String.Format("{0} and {1}", messageType, transmissionType);
BaseStationMessage message = _Implementation.Translate(text, 123);
if (messageType == BaseStationMessageType.Transmission)
{
Assert.AreEqual(transmissionType, message.TransmissionType, errorText);
}
else
{
Assert.AreEqual(BaseStationTransmissionType.None, message.TransmissionType, errorText);
}
}
}
}
public void BaseStationMessageHelper_ConvertToBaseStationTransmissionType_Converts_Text_Correctly()
{
foreach (BaseStationTransmissionType transmissionType in Enum.GetValues(typeof(BaseStationTransmissionType)))
{
string text = null;
switch (transmissionType)
{
case BaseStationTransmissionType.AirbornePosition: text = "3"; break;
case BaseStationTransmissionType.AirborneVelocity: text = "4"; break;
case BaseStationTransmissionType.AirToAir: text = "7"; break;
case BaseStationTransmissionType.AllCallReply: text = "8"; break;
case BaseStationTransmissionType.IdentificationAndCategory: text = "1"; break;
case BaseStationTransmissionType.None: continue;
case BaseStationTransmissionType.SurfacePosition: text = "2"; break;
case BaseStationTransmissionType.SurveillanceAlt: text = "5"; break;
case BaseStationTransmissionType.SurveillanceId: text = "6"; break;
default: throw new NotImplementedException();
}
Assert.AreEqual(transmissionType, BaseStationMessageHelper.ConvertToBaseStationTransmissionType(text), transmissionType.ToString());
}
}
public void BaseStationMessageHelper_ConvertToBaseStationMessageType_Converts_Unknown_Text_Correctly()
{
foreach (string text in new string[] { null, "", "HHH", " MSG", "ID " })
{
Assert.AreEqual(BaseStationMessageType.Unknown, BaseStationMessageHelper.ConvertToBaseStationMessageType(text));
}
}
public void BaseStationMessageHelperTests_ConvertToString_BaseStationMessageType_Converts_All_Types_Correctly()
{
foreach (BaseStationMessageType messageType in Enum.GetValues(typeof(BaseStationMessageType)))
{
string text = BaseStationMessageHelper.ConvertToString(messageType);
switch (messageType)
{
case BaseStationMessageType.NewAircraft: Assert.AreEqual("AIR", text); break;
case BaseStationMessageType.NewIdentifier: Assert.AreEqual("ID", text); break;
case BaseStationMessageType.StatusChange: Assert.AreEqual("STA", text); break;
case BaseStationMessageType.Transmission: Assert.AreEqual("MSG", text); break;
case BaseStationMessageType.Unknown: Assert.AreEqual("", text); break;
case BaseStationMessageType.UserClicked: Assert.AreEqual("SEL", text); break;
case BaseStationMessageType.UserDoubleClicked: Assert.AreEqual("CLK", text); break;
default: throw new NotImplementedException();
}
}
}
public void BaseStationMessageHelperTests_ConvertToString_BaseStationTransmissionType_Converts_All_Types_Correctly()
{
foreach (BaseStationTransmissionType transmissionType in Enum.GetValues(typeof(BaseStationTransmissionType)))
{
string text = BaseStationMessageHelper.ConvertToString(transmissionType);
switch (transmissionType)
{
case BaseStationTransmissionType.AirbornePosition: Assert.AreEqual("3", text); break;
case BaseStationTransmissionType.AirborneVelocity: Assert.AreEqual("4", text); break;
case BaseStationTransmissionType.AirToAir: Assert.AreEqual("7", text); break;
case BaseStationTransmissionType.AllCallReply: Assert.AreEqual("8", text); break;
case BaseStationTransmissionType.IdentificationAndCategory: Assert.AreEqual("1", text); break;
case BaseStationTransmissionType.None: Assert.AreEqual("", text); break;
case BaseStationTransmissionType.SurfacePosition: Assert.AreEqual("2", text); break;
case BaseStationTransmissionType.SurveillanceAlt: Assert.AreEqual("5", text); break;
case BaseStationTransmissionType.SurveillanceId: Assert.AreEqual("6", text); break;
default: throw new NotImplementedException();
}
}
}
public void BaseStationMessageHelper_ConvertToBaseStationMessageType_Converts_Text_Correctly()
{
foreach (BaseStationMessageType messageType in Enum.GetValues(typeof(BaseStationMessageType)))
{
string text = null;
switch (messageType)
{
case BaseStationMessageType.NewAircraft: text = "AIR"; break;
case BaseStationMessageType.NewIdentifier: text = "ID"; break;
case BaseStationMessageType.StatusChange: text = "STA"; break;
case BaseStationMessageType.Transmission: text = "MSG"; break;
case BaseStationMessageType.Unknown: continue;
case BaseStationMessageType.UserClicked: text = "SEL"; break;
case BaseStationMessageType.UserDoubleClicked: text = "CLK"; break;
default: throw new NotImplementedException();
}
Assert.AreEqual(messageType, BaseStationMessageHelper.ConvertToBaseStationMessageType(text), messageType.ToString());
}
}
public void BaseStationMessageHelper_ConvertToBaseStationStatusCode_Converts_Unknown_Text_Correctly()
{
foreach (string text in new string[] { null, "", "ad", " OK", "SL " })
{
Assert.AreEqual(BaseStationStatusCode.None, BaseStationMessageHelper.ConvertToBaseStationStatusCode(text));
}
}
public void BaseStationMessageHelper_ConvertToBaseStationTransmissionType_Converts_Unknown_Text_Correctly()
{
foreach (string text in new string[] { null, "", "0", "9", "10", "AA" })
{
Assert.AreEqual(BaseStationTransmissionType.None, BaseStationMessageHelper.ConvertToBaseStationTransmissionType(text));
}
}
public void BaseStationMessageTranslator_Translate_Parses_Transmission_Types_Correctly()
{
foreach(BaseStationTransmissionType transmissionType in Enum.GetValues(typeof(BaseStationTransmissionType))) {
if(transmissionType == BaseStationTransmissionType.None) continue;
string typeText = BaseStationMessageHelper.ConvertToString(transmissionType);
BaseStationMessage message = _Implementation.Translate(String.Format("MSG,{0},5,2056,7404F2,11267,2008/11/28,23:48:18.611,2008/11/28,23:53:19.161,,,,,,,,,,,,", typeText));
Assert.AreEqual(transmissionType, message.TransmissionType, transmissionType.ToString());
}
}
public void BaseStationMessageTranslator_Translate_Parses_Message_Types_Correctly()
{
foreach(BaseStationMessageType messageType in Enum.GetValues(typeof(BaseStationMessageType))) {
if(messageType == BaseStationMessageType.Unknown) continue;
string messageTypeText = BaseStationMessageHelper.ConvertToString(messageType);
string text = String.Format("{0},1,5,2056,7404F2,11267,2008/11/28,23:48:18.611,2008/11/28,23:53:19.161,,,,,,,,,,,,", messageTypeText);
BaseStationMessage message = _Implementation.Translate(text);
Assert.AreEqual(messageType, message.MessageType, messageType.ToString());
}
}
public void BaseStationMessageHelper_ConvertToBaseStationMessageType_Converts_Mlat_Message_Types_Correctly()
{
var isMlat = false;
var messageType = BaseStationMessageHelper.ConvertToBaseStationMessageType("MLAT", ref isMlat);
Assert.AreEqual(BaseStationMessageType.Transmission, messageType);
Assert.IsTrue(isMlat);
isMlat = false;
messageType = BaseStationMessageHelper.ConvertToBaseStationMessageType("MSG", ref isMlat);
Assert.AreEqual(BaseStationMessageType.Transmission, messageType);
Assert.IsFalse(isMlat); // Actually this is untouched, but it's definitely not true
}
public void BaseStationMessageHelperTests_ConvertToString_BaseStationStatusCode_Converts_All_Types_Correctly()
{
foreach (BaseStationStatusCode statusCode in Enum.GetValues(typeof(BaseStationStatusCode)))
{
string text = BaseStationMessageHelper.ConvertToString(statusCode);
switch (statusCode)
{
case BaseStationStatusCode.Delete: Assert.AreEqual("AD", text); break;
case BaseStationStatusCode.None: Assert.AreEqual("", text); break;
case BaseStationStatusCode.OK: Assert.AreEqual("OK", text); break;
case BaseStationStatusCode.PositionLost: Assert.AreEqual("PL", text); break;
case BaseStationStatusCode.Remove: Assert.AreEqual("RM", text); break;
case BaseStationStatusCode.SignalLost: Assert.AreEqual("SL", text); break;
default: throw new NotImplementedException();
}
}
}
public void BaseStationMessageHelper_ConvertToBaseStationStatusCode_Converts_Text_Correctly()
{
foreach (BaseStationStatusCode statusCode in Enum.GetValues(typeof(BaseStationStatusCode)))
{
string text = null;
switch (statusCode)
{
case BaseStationStatusCode.Delete: text = "AD"; break;
case BaseStationStatusCode.None: continue;
case BaseStationStatusCode.OK: text = "OK"; break;
case BaseStationStatusCode.PositionLost: text = "PL"; break;
case BaseStationStatusCode.Remove: text = "RM"; break;
case BaseStationStatusCode.SignalLost: text = "SL"; break;
default: throw new NotImplementedException();
}
Assert.AreEqual(statusCode, BaseStationMessageHelper.ConvertToBaseStationStatusCode(text), statusCode.ToString());
}
}
/// <summary>
/// See interface docs.
/// </summary>
/// <param name="text"></param>
/// <param name="signalLevel"></param>
/// <returns></returns>
public BaseStationMessage Translate(string text, int?signalLevel)
{
var result = new BaseStationMessage()
{
SignalLevel = signalLevel
};
if (!String.IsNullOrEmpty(text))
{
var isMlat = false;
string[] parts = text.Split(',');
for (int c = 0; c < parts.Length; c++)
{
string chunk = parts[c];
try {
if (!String.IsNullOrEmpty(chunk))
{
switch (c)
{
case 0: result.MessageType = BaseStationMessageHelper.ConvertToBaseStationMessageType(chunk, ref isMlat); break;
case 1: result.TransmissionType = result.MessageType == BaseStationMessageType.Transmission ? BaseStationMessageHelper.ConvertToBaseStationTransmissionType(chunk) : BaseStationTransmissionType.None; break;
case 2: result.SessionId = ParseInt(chunk); break;
case 3: result.AircraftId = ParseInt(chunk); break;
case 4: result.Icao24 = chunk == null ? null : chunk.ToUpperInvariant(); break;
case 5: result.FlightId = ParseInt(chunk); break;
case 6: result.MessageGenerated = ParseDate(chunk); break;
case 7: result.MessageGenerated = ParseTime(result.MessageGenerated, chunk); break;
case 8: result.MessageLogged = ParseDate(chunk); break;
case 9: result.MessageLogged = ParseTime(result.MessageLogged, chunk); break;
case 10: if (result.MessageType == BaseStationMessageType.StatusChange)
{
result.StatusCode = BaseStationMessageHelper.ConvertToBaseStationStatusCode(chunk);
}
else
{
result.Callsign = chunk.Replace("@", "").Trim();
} break;
case 11: result.Altitude = ParseInt(chunk); break;
case 12: result.GroundSpeed = ParseFloat(chunk); break;
case 13: result.Track = ParseFloat(chunk); break;
case 14: result.Latitude = ParseDouble(chunk); break;
case 15: result.Longitude = ParseDouble(chunk); break;
case 16: result.VerticalRate = ParseInt(chunk); break;
case 17: result.Squawk = ParseInt(chunk); if (result.Squawk == 0)
{
result.Squawk = null;
}
break;
case 18: result.SquawkHasChanged = ParseBool(chunk); break;
case 19: result.Emergency = ParseBool(chunk); break;
case 20: result.IdentActive = ParseBool(chunk); break;
case 21: result.OnGround = ParseBool(chunk); break;
}
}
} catch (Exception ex) {
Debug.WriteLine(String.Format("BaseStationMessageTranslator.Translate caught exception: {0}", ex.ToString()));
// I would prefer to pass ex as the inner exception to this. However Microsoft's Application.ThreadException unhandled exception handler
// strips off all outer exceptions and only shows the bottom-most exception - i.e., in our case, the exception from a Parse method. This
// is not useful in isolation, we need to know what was being translated, the context in which the exception was thrown. So I have ended
// up with this, which is not very nice but shows enough information in the unhandled exception handler to allow diagnosis of the problem.
throw new BaseStationTranslatorException($"{ex.Message} while translating \"{chunk}\" (chunk {c}) in \"{text}\"");
}
}
result.IsMlat = isMlat;
}
return(result);
}
public void BaseStationMessageTranslator_Translate_Parses_Status_Codes_Correctly()
{
foreach (BaseStationStatusCode statusCode in Enum.GetValues(typeof(BaseStationStatusCode)))
{
if (statusCode == BaseStationStatusCode.None)
{
continue;
}
string text = String.Format("STA,1,5,2056,7404F2,11267,2008/11/28,23:48:18.611,2008/11/28,23:53:19.161,{0},,,,,,,,,,,", BaseStationMessageHelper.ConvertToString(statusCode));
BaseStationMessage message = _Implementation.Translate(text, 123);
Assert.AreEqual(statusCode, message.StatusCode, statusCode.ToString());
}
}
