public SpeedZoneSTTarget(BaseSpeedTarget baseTarget)
: base(SpeedTargetType.ZoneST, baseTarget)
{
Debug.Assert(baseTarget.ParentStep.ParentConcreteWorkout.Category.SpeedZone.Zones.Count > 0);
Zone = baseTarget.ParentStep.ParentConcreteWorkout.Category.SpeedZone.Zones[0];
}
public SpeedRangeTarget(double minUnitsPerHour, double maxUnitsPerHour, Length.Units speedUnit, Speed.Units speedPace, BaseSpeedTarget baseTarget)
: this(baseTarget)
{
if (speedPace == Speed.Units.Pace)
{
SetRangeInMinutesPerUnit(minUnitsPerHour, maxUnitsPerHour, speedUnit);
}
else
{
SetRangeInUnitsPerHour(minUnitsPerHour, maxUnitsPerHour, speedUnit);
}
}
public static ITarget Create(ITarget.TargetType type, Stream stream, DataVersion version, RegularStep parent)
{
ITarget newTarget;
switch (type)
{
case ITarget.TargetType.Null:
{
newTarget = new NullTarget(stream, version, parent);
break;
}
case ITarget.TargetType.Speed:
{
newTarget = new BaseSpeedTarget(stream, version, parent);
break;
}
case ITarget.TargetType.HeartRate:
{
newTarget = new BaseHeartRateTarget(stream, version, parent);
break;
}
case ITarget.TargetType.Cadence:
{
newTarget = new BaseCadenceTarget(stream, version, parent);
break;
}
case ITarget.TargetType.Power:
{
newTarget = new BasePowerTarget(stream, version, parent);
break;
}
default:
{
Debug.Assert(false);
newTarget = null;
break;
}
}
parent.Target = newTarget;
return newTarget;
}
public void TestSerializeSTTargetExtensions()
{
XmlDocument testDocument = new XmlDocument();
XmlNode database;
XmlAttribute attribute;
Workout placeholderWorkout = new Workout("Test", PluginMain.GetApplication().Logbook.ActivityCategories[0]);
RegularStep placeholderStep = new RegularStep(placeholderWorkout);
ILogbook logbook = PluginMain.GetApplication().Logbook;
placeholderWorkout.Steps.AddStepToRoot(placeholderStep);
// Setup document
testDocument.AppendChild(testDocument.CreateXmlDeclaration("1.0", "UTF-8", "no"));
database = testDocument.CreateNode(XmlNodeType.Element, "TrainingCenterDatabase", null);
testDocument.AppendChild(database);
attribute = testDocument.CreateAttribute("xmlns", "xsi", GarminFitnessPlugin.Constants.xmlns);
attribute.Value = "http://www.w3.org/2001/XMLSchema-instance";
database.Attributes.Append(attribute);
// Cadence ST zone
BaseCadenceTarget cadenceTarget = new BaseCadenceTarget(placeholderStep);
cadenceTarget.ConcreteTarget = new CadenceZoneSTTarget(logbook.CadenceZones[0].Zones[2], cadenceTarget);
cadenceTarget.Serialize(database, "CadenceSTTarget1", testDocument);
Assert.GreaterOrEqual(placeholderWorkout.STExtensions.Count, 1, "Missing step extension node for CadenceST target");
Assert.AreEqual(cadenceSTTargetExtensionResult1,
placeholderWorkout.STExtensions[placeholderWorkout.STExtensions.Count - 1].OuterXml,
"Invalid CadenceST target extension serialization");
// Speed ST zone
BaseSpeedTarget speedTarget = new BaseSpeedTarget(placeholderStep);
speedTarget.ConcreteTarget = new SpeedZoneSTTarget(logbook.SpeedZones[0].Zones[1], speedTarget);
speedTarget.Serialize(database, "SpeedSTTarget1", testDocument);
Assert.GreaterOrEqual(placeholderWorkout.STExtensions.Count, 1, "Missing step extension node for SpeedST target");
Assert.AreEqual(speedSTTargetExtensionResult1,
placeholderWorkout.STExtensions[placeholderWorkout.STExtensions.Count - 1].OuterXml,
"Invalid SpeedST target extension serialization");
// HR ST zone
BaseHeartRateTarget hrTarget = new BaseHeartRateTarget(placeholderStep);
hrTarget.ConcreteTarget = new HeartRateZoneSTTarget(logbook.HeartRateZones[0].Zones[2], hrTarget);
hrTarget.Serialize(database, "HRSTTarget1", testDocument);
placeholderWorkout.Category = logbook.ActivityCategories[0].SubCategories[1];
hrTarget.ConcreteTarget = new HeartRateZoneSTTarget(logbook.HeartRateZones[1].Zones[2], hrTarget);
hrTarget.Serialize(database, "HRSTTarget3", testDocument);
hrTarget.ConcreteTarget = new HeartRateZoneSTTarget(logbook.HeartRateZones[1].Zones[4], hrTarget);
hrTarget.Serialize(database, "HRSTTarget4", testDocument);
Assert.GreaterOrEqual(placeholderWorkout.STExtensions.Count, 3, "Missing step extension node for HRST target");
Assert.AreEqual(hrSTTargetExtensionResult1,
placeholderWorkout.STExtensions[placeholderWorkout.STExtensions.Count - 3].OuterXml,
"Invalid HRST target extension serialization");
Assert.AreEqual(hrSTTargetExtensionResult2,
placeholderWorkout.STExtensions[placeholderWorkout.STExtensions.Count - 1].OuterXml,
"Invalid HRST target extension serialization");
Assert.AreEqual(placeholderWorkout.STExtensions[placeholderWorkout.STExtensions.Count - 1].LastChild.FirstChild.InnerText,
placeholderWorkout.STExtensions[placeholderWorkout.STExtensions.Count - 2].LastChild.FirstChild.InnerText,
"Matching HRST target extension are not identical");
Assert.AreNotEqual(placeholderWorkout.STExtensions[placeholderWorkout.STExtensions.Count - 1].LastChild.FirstChild.InnerText,
placeholderWorkout.STExtensions[placeholderWorkout.STExtensions.Count - 3].LastChild.FirstChild.InnerText,
"Mismatching HRST target extension are identical");
// Power ST zone
BasePowerTarget powerTarget = new BasePowerTarget(placeholderStep);
powerTarget.ConcreteTarget = new PowerZoneSTTarget(logbook.PowerZones[0].Zones[3], powerTarget);
powerTarget.Serialize(database, "PowerSTTarget1", testDocument);
Assert.GreaterOrEqual(placeholderWorkout.STExtensions.Count, 1, "Missing step extension node for PowerST target");
Assert.AreEqual(powerSTTargetExtensionResult1,
placeholderWorkout.STExtensions[placeholderWorkout.STExtensions.Count - 1].OuterXml,
"Invalid PowerST target extension serialization");
}
public void TestFITSerialization()
{
Workout placeholderWorkout = new Workout("Test", PluginMain.GetApplication().Logbook.ActivityCategories[0]);
RegularStep placeholderStep = new RegularStep(placeholderWorkout);
ILogbook logbook = PluginMain.GetApplication().Logbook;
bool exportHRAsMax = Options.Instance.ExportSportTracksHeartRateAsPercentMax;
bool exportPowerAsFTP = Options.Instance.ExportSportTracksPowerAsPercentFTP;
FITMessage serializedMessage = new FITMessage(FITGlobalMessageIds.WorkoutStep);
FITMessageField messageField;
// This is required to determine the step's id in the workout during serialization
placeholderWorkout.Steps.AddStepToRoot(placeholderStep);
// No target
NullTarget noTarget = new NullTarget(placeholderStep);
noTarget.FillFITStepMessage(serializedMessage);
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetType);
Assert.IsNotNull(messageField, "Invalid no target FIT serialization");
Assert.AreEqual((Byte)FITWorkoutStepTargetTypes.NoTarget, messageField.GetEnum(), "Invalid target type in field for target");
serializedMessage.Clear();
// Cadence targets
BaseCadenceTarget cadenceTarget = new BaseCadenceTarget(placeholderStep);
// Cadence range
cadenceTarget.ConcreteTarget = new CadenceRangeTarget(80, 90, cadenceTarget);
cadenceTarget.FillFITStepMessage(serializedMessage);
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetType);
Assert.IsNotNull(messageField, "Invalid CadenceRange target FIT serialization");
Assert.AreEqual((Byte)FITWorkoutStepTargetTypes.Cadence, messageField.GetEnum(), "Invalid target type in field for CadenceRange target");
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetValue);
Assert.IsNotNull(messageField, "Invalid CadenceRange target FIT serialization");
Assert.AreEqual(0, messageField.GetUInt32(), "Invalid zone value in field for CadenceRange target");
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetCustomValueLow);
Assert.IsNotNull(messageField, "Invalid CadenceRange target FIT serialization");
Assert.AreEqual(80, messageField.GetUInt32(), "Invalid lower value in field for CadenceRange target");
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetCustomValueHigh);
Assert.IsNotNull(messageField, "Invalid CadenceRange target FIT serialization");
Assert.AreEqual(90, messageField.GetUInt32(), "Invalid upper value in field for CadenceRange target");
serializedMessage.Clear();
cadenceTarget.ConcreteTarget = new CadenceRangeTarget(60, 120, cadenceTarget);
cadenceTarget.FillFITStepMessage(serializedMessage);
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetType);
Assert.IsNotNull(messageField, "Invalid CadenceRange target FIT serialization");
Assert.AreEqual((Byte)FITWorkoutStepTargetTypes.Cadence, messageField.GetEnum(), "Invalid target type in field for CadenceRange target");
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetValue);
Assert.IsNotNull(messageField, "Invalid CadenceRange target FIT serialization");
Assert.AreEqual(0, messageField.GetUInt32(), "Invalid zone value in field for CadenceRange target");
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetCustomValueLow);
Assert.IsNotNull(messageField, "Invalid CadenceRange target FIT serialization");
Assert.AreEqual(60, messageField.GetUInt32(), "Invalid lower value in field for CadenceRange target");
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetCustomValueHigh);
Assert.IsNotNull(messageField, "Invalid CadenceRange target FIT serialization");
Assert.AreEqual(120, messageField.GetUInt32(), "Invalid upper value in field for CadenceRange target");
serializedMessage.Clear();
// Cadence ST zone
cadenceTarget.ConcreteTarget = new CadenceZoneSTTarget(logbook.CadenceZones[0].Zones[2], cadenceTarget);
cadenceTarget.FillFITStepMessage(serializedMessage);
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetType);
Assert.IsNotNull(messageField, "Invalid CadenceST target FIT serialization");
Assert.AreEqual((Byte)FITWorkoutStepTargetTypes.Cadence, messageField.GetEnum(), "Invalid target type in field for CadenceST target");
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetValue);
Assert.IsNotNull(messageField, "Invalid CadenceRange target FIT serialization");
Assert.AreEqual(0, messageField.GetUInt32(), "Invalid zone value in field for CadenceRange target");
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetCustomValueLow);
Assert.IsNotNull(messageField, "Invalid CadenceRange target FIT serialization");
Assert.AreEqual(70, messageField.GetUInt32(), "Invalid lower value in field for CadenceRange target");
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetCustomValueHigh);
Assert.IsNotNull(messageField, "Invalid CadenceRange target FIT serialization");
Assert.AreEqual(85, messageField.GetUInt32(), "Invalid upper value in field for CadenceRange target");
serializedMessage.Clear();
cadenceTarget.ConcreteTarget = new CadenceZoneSTTarget(logbook.CadenceZones[0].Zones[4], cadenceTarget);
cadenceTarget.FillFITStepMessage(serializedMessage);
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetType);
Assert.IsNotNull(messageField, "Invalid CadenceST target FIT serialization");
Assert.AreEqual((Byte)FITWorkoutStepTargetTypes.Cadence, messageField.GetEnum(), "Invalid target type in field for CadenceST target");
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetValue);
Assert.IsNotNull(messageField, "Invalid CadenceRange target FIT serialization");
Assert.AreEqual(0, messageField.GetUInt32(), "Invalid zone value in field for CadenceRange target");
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetCustomValueLow);
Assert.IsNotNull(messageField, "Invalid CadenceRange target FIT serialization");
Assert.AreEqual(100, messageField.GetUInt32(), "Invalid lower value in field for CadenceRange target");
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetCustomValueHigh);
Assert.IsNotNull(messageField, "Invalid CadenceRange target FIT serialization");
Assert.AreEqual(120, messageField.GetUInt32(), "Invalid upper value in field for CadenceRange target");
serializedMessage.Clear();
// Speed targets
BaseSpeedTarget speedTarget = new BaseSpeedTarget(placeholderStep);
// Speed range
placeholderWorkout.Category = logbook.ActivityCategories[0].SubCategories[3];
speedTarget.ConcreteTarget = new SpeedRangeTarget(20, 30, Length.Units.Kilometer, Speed.Units.Speed, speedTarget);
speedTarget.FillFITStepMessage(serializedMessage);
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetType);
Assert.IsNotNull(messageField, "Invalid SpeedRange target FIT serialization");
Assert.AreEqual((Byte)FITWorkoutStepTargetTypes.Speed, messageField.GetEnum(), "Invalid target type in field for SpeedRange target");
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetValue);
Assert.IsNotNull(messageField, "Invalid SpeedRange target FIT serialization");
Assert.AreEqual(0, messageField.GetUInt32(), "Invalid zone value in field for SpeedRange target");
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetCustomValueLow);
Assert.IsNotNull(messageField, "Invalid SpeedRange target FIT serialization");
Assert.AreEqual(5555, messageField.GetUInt32(), "Invalid lower value in field for SpeedRange target");
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetCustomValueHigh);
Assert.IsNotNull(messageField, "Invalid SpeedRange target FIT serialization");
Assert.AreEqual(8333, messageField.GetUInt32(), "Invalid upper value in field for SpeedRange target");
serializedMessage.Clear();
speedTarget.ConcreteTarget = new SpeedRangeTarget(20, 30, Length.Units.Mile, Speed.Units.Speed, speedTarget);
speedTarget.FillFITStepMessage(serializedMessage);
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetType);
Assert.IsNotNull(messageField, "Invalid SpeedRange target FIT serialization");
Assert.AreEqual((Byte)FITWorkoutStepTargetTypes.Speed, messageField.GetEnum(), "Invalid target type in field for SpeedRange target");
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetValue);
Assert.IsNotNull(messageField, "Invalid SpeedRange target FIT serialization");
Assert.AreEqual(0, messageField.GetUInt32(), "Invalid zone value in field for SpeedRange target");
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetCustomValueLow);
Assert.IsNotNull(messageField, "Invalid SpeedRange target FIT serialization");
Assert.AreEqual(8940, messageField.GetUInt32(), "Invalid lower value in field for SpeedRange target");
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetCustomValueHigh);
Assert.IsNotNull(messageField, "Invalid SpeedRange target FIT serialization");
Assert.AreEqual(13411, messageField.GetUInt32(), "Invalid upper value in field for SpeedRange target");
serializedMessage.Clear();
// Pace shouldn't change the values saved
placeholderWorkout.Category = logbook.ActivityCategories[0].SubCategories[2];
speedTarget.FillFITStepMessage(serializedMessage);
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetType);
Assert.IsNotNull(messageField, "Invalid SpeedRange pace target FIT serialization");
Assert.AreEqual((Byte)FITWorkoutStepTargetTypes.Speed, messageField.GetEnum(), "Invalid target type in field for SpeedRange target");
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetValue);
Assert.IsNotNull(messageField, "Invalid SpeedRange pace target FIT serialization");
Assert.AreEqual(0, messageField.GetUInt32(), "Invalid zone value in field for SpeedRange pace target");
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetCustomValueLow);
Assert.IsNotNull(messageField, "Invalid SpeedRange pace target FIT serialization");
Assert.AreEqual(8940, messageField.GetUInt32(), "Invalid lower value in field for SpeedRange pace target");
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetCustomValueHigh);
Assert.IsNotNull(messageField, "Invalid SpeedRange pace target FIT serialization");
Assert.AreEqual(13411, messageField.GetUInt32(), "Invalid upper value in field for SpeedRange pace target");
serializedMessage.Clear();
// Speed Garmin zone
speedTarget.ConcreteTarget = new SpeedZoneGTCTarget(1, speedTarget);
speedTarget.FillFITStepMessage(serializedMessage);
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetType);
Assert.IsNotNull(messageField, "Invalid SpeedGTC target FIT serialization");
Assert.AreEqual((Byte)FITWorkoutStepTargetTypes.Speed, messageField.GetEnum(), "Invalid target type in field for SpeedGTC target");
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetValue);
Assert.IsNotNull(messageField, "Invalid SpeedGTC target FIT serialization");
Assert.AreEqual(1, messageField.GetUInt32(), "Invalid zone value in field for SpeedGTC target");
serializedMessage.Clear();
speedTarget.ConcreteTarget = new SpeedZoneGTCTarget(3, speedTarget);
speedTarget.FillFITStepMessage(serializedMessage);
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetType);
Assert.IsNotNull(messageField, "Invalid SpeedGTC target FIT serialization");
Assert.AreEqual((Byte)FITWorkoutStepTargetTypes.Speed, messageField.GetEnum(), "Invalid target type in field for SpeedGTC target");
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetValue);
Assert.IsNotNull(messageField, "Invalid SpeedGTC target FIT serialization");
Assert.AreEqual(3, messageField.GetUInt32(), "Invalid zone value in field for SpeedGTC target");
serializedMessage.Clear();
// Speed ST zone
Options.Instance.ExportSportTracksHeartRateAsPercentMax = false;
placeholderWorkout.Category = logbook.ActivityCategories[0].SubCategories[3];
speedTarget.ConcreteTarget = new SpeedZoneSTTarget(logbook.SpeedZones[0].Zones[1], speedTarget);
speedTarget.FillFITStepMessage(serializedMessage);
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetType);
Assert.IsNotNull(messageField, "Invalid SpeedST target FIT serialization");
Assert.AreEqual((Byte)FITWorkoutStepTargetTypes.Speed, messageField.GetEnum(), "Invalid target type in field for target");
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetValue);
Assert.IsNotNull(messageField, "Invalid SpeedRange target FIT serialization");
Assert.AreEqual(0, messageField.GetUInt32(), "Invalid zone value in field for SpeedRange target");
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetCustomValueLow);
Assert.IsNotNull(messageField, "Invalid SpeedRange target FIT serialization");
Assert.AreEqual(2777, messageField.GetUInt32(), "Invalid lower value in field for SpeedRange target");
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetCustomValueHigh);
Assert.IsNotNull(messageField, "Invalid SpeedRange target FIT serialization");
Assert.AreEqual(5555, messageField.GetUInt32(), "Invalid upper value in field for SpeedRange target");
serializedMessage.Clear();
speedTarget.ConcreteTarget = new SpeedZoneSTTarget(logbook.SpeedZones[0].Zones[2], speedTarget);
speedTarget.FillFITStepMessage(serializedMessage);
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetType);
Assert.IsNotNull(messageField, "Invalid SpeedST target FIT serialization");
Assert.AreEqual((Byte)FITWorkoutStepTargetTypes.Speed, messageField.GetEnum(), "Invalid target type in field for target");
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetValue);
Assert.IsNotNull(messageField, "Invalid SpeedRange target FIT serialization");
Assert.AreEqual(0, messageField.GetUInt32(), "Invalid zone value in field for SpeedRange target");
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetCustomValueLow);
Assert.IsNotNull(messageField, "Invalid SpeedRange target FIT serialization");
Assert.AreEqual(5555, messageField.GetUInt32(), "Invalid lower value in field for SpeedRange target");
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetCustomValueHigh);
Assert.IsNotNull(messageField, "Invalid SpeedRange target FIT serialization");
Assert.AreEqual(8333, messageField.GetUInt32(), "Invalid upper value in field for SpeedRange target");
serializedMessage.Clear();
// Pace shouldn't change the values saved
placeholderWorkout.Category = logbook.ActivityCategories[0].SubCategories[2];
speedTarget.FillFITStepMessage(serializedMessage);
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetType);
Assert.IsNotNull(messageField, "Invalid SpeedST target FIT serialization");
Assert.AreEqual((Byte)FITWorkoutStepTargetTypes.Speed, messageField.GetEnum(), "Invalid target type in field for target");
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetValue);
Assert.IsNotNull(messageField, "Invalid SpeedRange pace target FIT serialization");
Assert.AreEqual(0, messageField.GetUInt32(), "Invalid zone value in field for SpeedRange pace target");
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetCustomValueLow);
Assert.IsNotNull(messageField, "Invalid SpeedRange pace target FIT serialization");
Assert.AreEqual(5555, messageField.GetUInt32(), "Invalid lower value in field for SpeedRange pace target");
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetCustomValueHigh);
Assert.IsNotNull(messageField, "Invalid SpeedRange pace target FIT serialization");
Assert.AreEqual(8333, messageField.GetUInt32(), "Invalid upper value in field for SpeedRange pace target");
serializedMessage.Clear();
// Heart rate targets
BaseHeartRateTarget hrTarget = new BaseHeartRateTarget(placeholderStep);
// HR range
hrTarget.ConcreteTarget = new HeartRateRangeTarget(130, 170, false, hrTarget);
hrTarget.FillFITStepMessage(serializedMessage);
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetType);
Assert.IsNotNull(messageField, "Invalid HRRange target FIT serialization");
Assert.AreEqual((Byte)FITWorkoutStepTargetTypes.HeartRate, messageField.GetEnum(), "Invalid target type in field for HRRange target");
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetValue);
Assert.IsNotNull(messageField, "Invalid HRRange target FIT serialization");
Assert.AreEqual(0, messageField.GetUInt32(), "Invalid zone value in field for HRRange target");
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetCustomValueLow);
Assert.IsNotNull(messageField, "Invalid HRRange target FIT serialization");
Assert.AreEqual(230, messageField.GetUInt32(), "Invalid lower value in field for HRRange target");
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetCustomValueHigh);
Assert.IsNotNull(messageField, "Invalid HRRange target FIT serialization");
Assert.AreEqual(270, messageField.GetUInt32(), "Invalid upper value in field for HRRange target");
serializedMessage.Clear();
hrTarget.ConcreteTarget = new HeartRateRangeTarget(100, 190, false, hrTarget);
hrTarget.FillFITStepMessage(serializedMessage);
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetType);
Assert.IsNotNull(messageField, "Invalid HRRange target FIT serialization");
Assert.AreEqual((Byte)FITWorkoutStepTargetTypes.HeartRate, messageField.GetEnum(), "Invalid target type in field for HRRange target");
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetValue);
Assert.IsNotNull(messageField, "Invalid HRRange target FIT serialization");
Assert.AreEqual(0, messageField.GetUInt32(), "Invalid zone value in field for HRRange target");
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetCustomValueLow);
Assert.IsNotNull(messageField, "Invalid HRRange target FIT serialization");
Assert.AreEqual(200, messageField.GetUInt32(), "Invalid lower value in field for HRRange target");
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetCustomValueHigh);
Assert.IsNotNull(messageField, "Invalid HRRange target FIT serialization");
Assert.AreEqual(290, messageField.GetUInt32(), "Invalid upper value in field for HRRange target");
serializedMessage.Clear();
hrTarget.ConcreteTarget = new HeartRateRangeTarget(50, 70, true, hrTarget);
hrTarget.FillFITStepMessage(serializedMessage);
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetType);
Assert.IsNotNull(messageField, "Invalid HRRange %Max target FIT serialization");
Assert.AreEqual((Byte)FITWorkoutStepTargetTypes.HeartRate, messageField.GetEnum(), "Invalid target type in field for HRRange %Max target");
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetValue);
Assert.IsNotNull(messageField, "Invalid HRRange %Max target FIT serialization");
Assert.AreEqual(0, messageField.GetUInt32(), "Invalid zone value in field for HRRange %Max target");
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetCustomValueLow);
Assert.IsNotNull(messageField, "Invalid HRRange %Max target FIT serialization");
Assert.AreEqual(50, messageField.GetUInt32(), "Invalid lower value in field for HRRange %Max target");
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetCustomValueHigh);
Assert.IsNotNull(messageField, "Invalid HRRange %Max target FIT serialization");
Assert.AreEqual(70, messageField.GetUInt32(), "Invalid upper value in field for HRRange %Max target");
serializedMessage.Clear();
// HR Garmin zone
hrTarget.ConcreteTarget = new HeartRateZoneGTCTarget(1, hrTarget);
hrTarget.FillFITStepMessage(serializedMessage);
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetType);
Assert.IsNotNull(messageField, "Invalid HRGTC target FIT serialization");
Assert.AreEqual((Byte)FITWorkoutStepTargetTypes.HeartRate, messageField.GetEnum(), "Invalid target type in field for HRGTC target");
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetValue);
Assert.IsNotNull(messageField, "Invalid HRGTC target FIT serialization");
Assert.AreEqual(1, messageField.GetUInt32(), "Invalid zone value in field for HRGTC target");
serializedMessage.Clear();
hrTarget.ConcreteTarget = new HeartRateZoneGTCTarget(3, hrTarget);
hrTarget.FillFITStepMessage(serializedMessage);
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetType);
Assert.IsNotNull(messageField, "Invalid HRGTC target FIT serialization");
Assert.AreEqual((Byte)FITWorkoutStepTargetTypes.HeartRate, messageField.GetEnum(), "Invalid target type in field for HRGTC target");
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetValue);
Assert.IsNotNull(messageField, "Invalid HRGTC target FIT serialization");
Assert.AreEqual(3, messageField.GetUInt32(), "Invalid zone value in field for HRGTC target");
serializedMessage.Clear();
// HR ST zone
Options.Instance.ExportSportTracksHeartRateAsPercentMax = false;
hrTarget.ConcreteTarget = new HeartRateZoneSTTarget(logbook.HeartRateZones[0].Zones[2], hrTarget);
hrTarget.FillFITStepMessage(serializedMessage);
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetType);
Assert.IsNotNull(messageField, "Invalid HRST target FIT serialization");
Assert.AreEqual((Byte)FITWorkoutStepTargetTypes.HeartRate, messageField.GetEnum(), "Invalid target type in field for HRST target");
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetValue);
Assert.IsNotNull(messageField, "Invalid HRST target FIT serialization");
Assert.AreEqual(0, messageField.GetUInt32(), "Invalid zone value in field for HRST target");
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetCustomValueLow);
Assert.IsNotNull(messageField, "Invalid HRST target FIT serialization");
Assert.AreEqual(240, messageField.GetUInt32(), "Invalid lower value in field for HRST target");
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetCustomValueHigh);
Assert.IsNotNull(messageField, "Invalid HRST target FIT serialization");
Assert.AreEqual(260, messageField.GetUInt32(), "Invalid upper value in field for HRST target");
serializedMessage.Clear();
hrTarget.ConcreteTarget = new HeartRateZoneSTTarget(logbook.HeartRateZones[0].Zones[4], hrTarget);
hrTarget.FillFITStepMessage(serializedMessage);
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetType);
Assert.IsNotNull(messageField, "Invalid HRST target FIT serialization");
Assert.AreEqual((Byte)FITWorkoutStepTargetTypes.HeartRate, messageField.GetEnum(), "Invalid target type in field for HRST target");
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetValue);
Assert.IsNotNull(messageField, "Invalid HRST target FIT serialization");
Assert.AreEqual(0, messageField.GetUInt32(), "Invalid zone value in field for HRST target");
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetCustomValueLow);
Assert.IsNotNull(messageField, "Invalid HRST target FIT serialization");
Assert.AreEqual(280, messageField.GetUInt32(), "Invalid lower value in field for HRST target");
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetCustomValueHigh);
Assert.IsNotNull(messageField, "Invalid HRST target FIT serialization");
Assert.AreEqual(340, messageField.GetUInt32(), "Invalid upper value in field for HRST target");
serializedMessage.Clear();
placeholderWorkout.Category = logbook.ActivityCategories[0].SubCategories[1];
Options.Instance.ExportSportTracksHeartRateAsPercentMax = true;
hrTarget.ConcreteTarget = new HeartRateZoneSTTarget(logbook.HeartRateZones[1].Zones[2], hrTarget);
hrTarget.FillFITStepMessage(serializedMessage);
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetType);
Assert.IsNotNull(messageField, "Invalid HRST %Max target FIT serialization");
Assert.AreEqual((Byte)FITWorkoutStepTargetTypes.HeartRate, messageField.GetEnum(), "Invalid target type in field for HRST %Max target");
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetValue);
Assert.IsNotNull(messageField, "Invalid HRST %Max target FIT serialization");
Assert.AreEqual(0, messageField.GetUInt32(), "Invalid zone value in field for HRST %Max target");
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetCustomValueLow);
Assert.IsNotNull(messageField, "Invalid HRST %Max target FIT serialization");
Assert.AreEqual(68, messageField.GetUInt32(), "Invalid lower value in field for HRST %Max target");
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetCustomValueHigh);
Assert.IsNotNull(messageField, "Invalid HRST %Max target FIT serialization");
Assert.AreEqual(82, messageField.GetUInt32(), "Invalid upper value in field for HRST %Max target");
serializedMessage.Clear();
// Power targets
BasePowerTarget powerTarget = new BasePowerTarget(placeholderStep);
// Power range
powerTarget.ConcreteTarget = new PowerRangeTarget(150, 200, false, powerTarget);
powerTarget.FillFITStepMessage(serializedMessage);
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetType);
Assert.IsNotNull(messageField, "Invalid PowerRange target FIT serialization");
Assert.AreEqual((Byte)FITWorkoutStepTargetTypes.Power, messageField.GetEnum(), "Invalid target type in field for PowerRange target");
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetValue);
Assert.IsNotNull(messageField, "Invalid PowerRange target FIT serialization");
Assert.AreEqual(0, messageField.GetUInt32(), "Invalid zone value in field for PowerRange target");
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetCustomValueLow);
Assert.IsNotNull(messageField, "Invalid PowerRange target FIT serialization");
Assert.AreEqual(1150, messageField.GetUInt32(), "Invalid lower value in field for PowerRange target");
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetCustomValueHigh);
Assert.IsNotNull(messageField, "Invalid PowerRange target FIT serialization");
Assert.AreEqual(1200, messageField.GetUInt32(), "Invalid upper value in field for PowerRange target");
serializedMessage.Clear();
powerTarget.ConcreteTarget = new PowerRangeTarget(300, 400, false, powerTarget);
powerTarget.FillFITStepMessage(serializedMessage);
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetType);
Assert.IsNotNull(messageField, "Invalid PowerRange target FIT serialization");
Assert.AreEqual((Byte)FITWorkoutStepTargetTypes.Power, messageField.GetEnum(), "Invalid target type in field for target");
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetValue);
Assert.IsNotNull(messageField, "Invalid PowerRange target FIT serialization");
Assert.AreEqual(0, messageField.GetUInt32(), "Invalid zone value in field for PowerRange target");
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetCustomValueLow);
Assert.IsNotNull(messageField, "Invalid PowerRange target FIT serialization");
Assert.AreEqual(1300, messageField.GetUInt32(), "Invalid lower value in field for PowerRange target");
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetCustomValueHigh);
Assert.IsNotNull(messageField, "Invalid PowerRange target FIT serialization");
Assert.AreEqual(1400, messageField.GetUInt32(), "Invalid upper value in field for PowerRange target");
serializedMessage.Clear();
powerTarget.ConcreteTarget = new PowerRangeTarget(67, 80, true, powerTarget);
powerTarget.FillFITStepMessage(serializedMessage);
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetType);
Assert.IsNotNull(messageField, "Invalid PowerRange %FTP target FIT serialization");
Assert.AreEqual((Byte)FITWorkoutStepTargetTypes.Power, messageField.GetEnum(), "Invalid target type in field for PowerRange %FTP target");
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetValue);
Assert.IsNotNull(messageField, "Invalid PowerRange %FTP target FIT serialization");
Assert.AreEqual(0, messageField.GetUInt32(), "Invalid zone value in field for PowerRange %FTP target");
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetCustomValueLow);
Assert.IsNotNull(messageField, "Invalid PowerRange %FTP target FIT serialization");
Assert.AreEqual(67, messageField.GetUInt32(), "Invalid lower value in field for PowerRange %FTP target");
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetCustomValueHigh);
Assert.IsNotNull(messageField, "Invalid PowerRange %FTP target FIT serialization");
Assert.AreEqual(80, messageField.GetUInt32(), "Invalid upper value in field for PowerRange %FTP target");
serializedMessage.Clear();
// Power Garmin zone
powerTarget.ConcreteTarget = new PowerZoneGTCTarget(1, powerTarget);
powerTarget.FillFITStepMessage(serializedMessage);
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetType);
Assert.IsNotNull(messageField, "Invalid PowerGTC target FIT serialization");
Assert.AreEqual((Byte)FITWorkoutStepTargetTypes.Power, messageField.GetEnum(), "Invalid target type in field for PowerGTC target");
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetValue);
Assert.IsNotNull(messageField, "Invalid PowerGTC target FIT serialization");
Assert.AreEqual(1, messageField.GetUInt32(), "Invalid zone value in field for PowerGTC target");
serializedMessage.Clear();
powerTarget.ConcreteTarget = new PowerZoneGTCTarget(3, powerTarget);
powerTarget.FillFITStepMessage(serializedMessage);
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetType);
Assert.IsNotNull(messageField, "Invalid PowerGTC target FIT serialization");
Assert.AreEqual((Byte)FITWorkoutStepTargetTypes.Power, messageField.GetEnum(), "Invalid target type in field for target");
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetValue);
Assert.IsNotNull(messageField, "Invalid PowerGTC target FIT serialization");
Assert.AreEqual(3, messageField.GetUInt32(), "Invalid zone value in field for PowerGTC target");
serializedMessage.Clear();
// Power ST zone
placeholderWorkout.Category = logbook.ActivityCategories[0].SubCategories[4];
Options.Instance.ExportSportTracksPowerAsPercentFTP = false;
powerTarget.ConcreteTarget = new PowerZoneSTTarget(logbook.PowerZones[0].Zones[1], powerTarget);
powerTarget.FillFITStepMessage(serializedMessage);
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetType);
Assert.IsNotNull(messageField, "Invalid PowerST target FIT serialization");
Assert.AreEqual((Byte)FITWorkoutStepTargetTypes.Power, messageField.GetEnum(), "Invalid target type in field for PowerST target");
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetValue);
Assert.IsNotNull(messageField, "Invalid PowerST target FIT serialization");
Assert.AreEqual(0, messageField.GetUInt32(), "Invalid zone value in field for PowerST target");
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetCustomValueLow);
Assert.IsNotNull(messageField, "Invalid PowerST target FIT serialization");
Assert.AreEqual(1150, messageField.GetUInt32(), "Invalid lower value in field for PowerST target");
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetCustomValueHigh);
Assert.IsNotNull(messageField, "Invalid PowerSTFTP target FIT serialization");
Assert.AreEqual(1200, messageField.GetUInt32(), "Invalid upper value in field for PowerST target");
serializedMessage.Clear();
powerTarget.ConcreteTarget = new PowerZoneSTTarget(logbook.PowerZones[0].Zones[3], powerTarget);
powerTarget.FillFITStepMessage(serializedMessage);
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetType);
Assert.IsNotNull(messageField, "Invalid PowerST target FIT serialization");
Assert.AreEqual((Byte)FITWorkoutStepTargetTypes.Power, messageField.GetEnum(), "Invalid target type in field for PowerST target");
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetValue);
Assert.IsNotNull(messageField, "Invalid PowerST target FIT serialization");
Assert.AreEqual(0, messageField.GetUInt32(), "Invalid zone value in field for PowerST target");
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetCustomValueLow);
Assert.IsNotNull(messageField, "Invalid PowerST target FIT serialization");
Assert.AreEqual(1300, messageField.GetUInt32(), "Invalid lower value in field for PowerST target");
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetCustomValueHigh);
Assert.IsNotNull(messageField, "Invalid PowerSTFTP target FIT serialization");
Assert.AreEqual(1400, messageField.GetUInt32(), "Invalid upper value in field for PowerST target");
serializedMessage.Clear();
Options.Instance.ExportSportTracksPowerAsPercentFTP = true;
powerTarget.FillFITStepMessage(serializedMessage);
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetType);
Assert.IsNotNull(messageField, "Invalid PowerST %FTP target FIT serialization");
Assert.AreEqual((Byte)FITWorkoutStepTargetTypes.Power, messageField.GetEnum(), "Invalid target type in field for PowerST %FTP target");
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetValue);
Assert.IsNotNull(messageField, "Invalid PowerST %FTP target FIT serialization");
Assert.AreEqual(0, messageField.GetUInt32(), "Invalid zone value in field for PowerST %FTP target");
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetCustomValueLow);
Assert.IsNotNull(messageField, "Invalid PowerST %FTP target FIT serialization");
Assert.AreEqual(120, messageField.GetUInt32(), "Invalid lower value in field for PowerST %FTP target");
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetCustomValueHigh);
Assert.IsNotNull(messageField, "Invalid PowerST %FTP target FIT serialization");
Assert.AreEqual(160, messageField.GetUInt32(), "Invalid upper value in field for PowerST %FTP target");
serializedMessage.Clear();
// Make sure to reset options to previous values
Options.Instance.ExportSportTracksHeartRateAsPercentMax = exportHRAsMax;
Options.Instance.ExportSportTracksPowerAsPercentFTP = exportPowerAsFTP;
}
public void TestTCXSerialization()
{
XmlDocument testDocument = new XmlDocument();
XmlNode database;
XmlAttribute attribute;
Workout placeholderWorkout = new Workout("Test", PluginMain.GetApplication().Logbook.ActivityCategories[0]);
RegularStep placeholderStep = new RegularStep(placeholderWorkout);
ILogbook logbook = PluginMain.GetApplication().Logbook;
bool exportHRAsMax = Options.Instance.ExportSportTracksHeartRateAsPercentMax;
bool exportPowerAsFTP = Options.Instance.ExportSportTracksPowerAsPercentFTP;
int targetPosition1;
int targetPosition2;
// This is required to determine the step's id in the workout during serialization
placeholderWorkout.Steps.AddStepToRoot(placeholderStep);
// Setup document
testDocument.AppendChild(testDocument.CreateXmlDeclaration("1.0", "UTF-8", "no"));
database = testDocument.CreateNode(XmlNodeType.Element, "TrainingCenterDatabase", null);
testDocument.AppendChild(database);
attribute = testDocument.CreateAttribute("xmlns", "xsi", GarminFitnessPlugin.Constants.xmlns);
attribute.Value = "http://www.w3.org/2001/XMLSchema-instance";
database.Attributes.Append(attribute);
// No target
NullTarget noTarget = new NullTarget(placeholderStep);
noTarget.Serialize(database, "NoTarget", testDocument);
targetPosition1 = testDocument.InnerXml.IndexOf(noTargetResult);
Assert.GreaterOrEqual(targetPosition1, 0, "Invalid no target serialization");
// Cadence targets
BaseCadenceTarget cadenceTarget = new BaseCadenceTarget(placeholderStep);
// Cadence range
cadenceTarget.ConcreteTarget = new CadenceRangeTarget(80, 90, cadenceTarget);
cadenceTarget.Serialize(database, "CadenceRangeTarget1", testDocument);
targetPosition1 = testDocument.InnerXml.IndexOf(cadenceRangeTargetResult1);
Assert.GreaterOrEqual(targetPosition1, 0, "Invalid CadenceRange target serialization");
cadenceTarget.ConcreteTarget = new CadenceRangeTarget(60, 120, cadenceTarget);
cadenceTarget.Serialize(database, "CadenceRangeTarget2", testDocument);
targetPosition2 = testDocument.InnerXml.IndexOf(cadenceRangeTargetResult2);
Assert.GreaterOrEqual(targetPosition2, 0, "Invalid CadenceRange target serialization");
Assert.Greater(targetPosition2, targetPosition1, "CadenceRange target serializations don't differ");
// Cadence ST zone
cadenceTarget.ConcreteTarget = new CadenceZoneSTTarget(logbook.CadenceZones[0].Zones[2], cadenceTarget);
cadenceTarget.Serialize(database, "CadenceSTTarget1", testDocument);
targetPosition1 = testDocument.InnerXml.IndexOf(cadenceSTTargetResult1);
Assert.GreaterOrEqual(targetPosition1, 0, "Invalid CadenceST target serialization");
cadenceTarget.ConcreteTarget = new CadenceZoneSTTarget(logbook.CadenceZones[0].Zones[4], cadenceTarget);
cadenceTarget.Serialize(database, "CadenceSTTarget2", testDocument);
targetPosition2 = testDocument.InnerXml.IndexOf(cadenceSTTargetResult2);
Assert.GreaterOrEqual(targetPosition2, 0, "Invalid CadenceST target serialization");
Assert.Greater(targetPosition2, targetPosition1, "CadenceST target serializations don't differ");
// Speed targets
BaseSpeedTarget speedTarget = new BaseSpeedTarget(placeholderStep);
// Speed range
placeholderWorkout.Category = logbook.ActivityCategories[0].SubCategories[2];
speedTarget.ConcreteTarget = new SpeedRangeTarget(20, 30, Length.Units.Kilometer, Speed.Units.Speed, speedTarget);
speedTarget.Serialize(database, "SpeedRangeTarget1", testDocument);
targetPosition1 = testDocument.InnerXml.IndexOf(speedRangeTargetResult1);
Assert.GreaterOrEqual(targetPosition1, 0, "Invalid SpeedRange target serialization");
speedTarget.ConcreteTarget = new SpeedRangeTarget(20, 30, Length.Units.Mile, Speed.Units.Speed, speedTarget);
speedTarget.Serialize(database, "SpeedRangeTarget2", testDocument);
targetPosition2 = testDocument.InnerXml.IndexOf(speedRangeTargetResult2);
Assert.GreaterOrEqual(targetPosition2, 0, "Invalid SpeedRange target serialization");
Assert.Greater(targetPosition2, targetPosition1, "SpeedRange target serializations don't differ");
placeholderWorkout.Category = logbook.ActivityCategories[0].SubCategories[3];
speedTarget.ConcreteTarget = new SpeedRangeTarget(20, 30, Length.Units.Kilometer, Speed.Units.Speed, speedTarget);
speedTarget.Serialize(database, "SpeedRangeTarget3", testDocument);
targetPosition1 = testDocument.InnerXml.IndexOf(speedRangeTargetResult3);
Assert.GreaterOrEqual(targetPosition1, 0, "Invalid SpeedRange pace target serialization");
speedTarget.ConcreteTarget = new SpeedRangeTarget(7.5, 15, Length.Units.Mile, Speed.Units.Pace, speedTarget);
speedTarget.Serialize(database, "SpeedRangeTarget4", testDocument);
targetPosition2 = testDocument.InnerXml.IndexOf(speedRangeTargetResult4);
Assert.GreaterOrEqual(targetPosition2, 0, "Invalid SpeedRRange pace target serialization");
Assert.Greater(targetPosition2, targetPosition1, "SpeedRange pace target serializations don't differ");
// Speed Garmin zone
speedTarget.ConcreteTarget = new SpeedZoneGTCTarget(1, speedTarget);
speedTarget.Serialize(database, "SpeedGTCTarget1", testDocument);
targetPosition1 = testDocument.InnerXml.IndexOf(speedGTCTargetResult1);
Assert.GreaterOrEqual(targetPosition1, 0, "Invalid SpeedGTC target serialization");
speedTarget.ConcreteTarget = new SpeedZoneGTCTarget(3, speedTarget);
speedTarget.Serialize(database, "SpeedGTCTarget2", testDocument);
targetPosition2 = testDocument.InnerXml.IndexOf(speedGTCTargetResult2);
Assert.GreaterOrEqual(targetPosition2, 0, "Invalid SpeedGTC target serialization");
Assert.Greater(targetPosition2, targetPosition1, "SpeedGTC target serializations don't differ");
// Speed ST zone
placeholderWorkout.Category = logbook.ActivityCategories[0].SubCategories[2];
Options.Instance.ExportSportTracksHeartRateAsPercentMax = false;
speedTarget.ConcreteTarget = new SpeedZoneSTTarget(logbook.SpeedZones[0].Zones[1], speedTarget);
speedTarget.Serialize(database, "SpeedSTTarget1", testDocument);
targetPosition1 = testDocument.InnerXml.IndexOf(speedSTTargetResult1);
Assert.GreaterOrEqual(targetPosition1, 0, "Invalid SpeedRST target serialization");
speedTarget.ConcreteTarget = new SpeedZoneSTTarget(logbook.SpeedZones[0].Zones[2], speedTarget);
speedTarget.Serialize(database, "SpeedSTTarget2", testDocument);
targetPosition2 = testDocument.InnerXml.IndexOf(speedSTTargetResult2);
Assert.GreaterOrEqual(targetPosition2, 0, "Invalid SpeedRST target serialization");
Assert.Greater(targetPosition2, targetPosition1, "SpeedRST target serializations don't differ");
placeholderWorkout.Category = logbook.ActivityCategories[0].SubCategories[3];
speedTarget.ConcreteTarget = new SpeedZoneSTTarget(logbook.SpeedZones[0].Zones[1], speedTarget);
speedTarget.Serialize(database, "SpeedSTTarget3", testDocument);
targetPosition1 = testDocument.InnerXml.IndexOf(speedSTTargetResult3);
Assert.GreaterOrEqual(targetPosition1, 0, "Invalid SpeedRST %Max target serialization");
speedTarget.ConcreteTarget = new SpeedZoneSTTarget(logbook.SpeedZones[0].Zones[2], speedTarget);
speedTarget.Serialize(database, "SpeedSTTarget4", testDocument);
targetPosition2 = testDocument.InnerXml.IndexOf(speedSTTargetResult4);
Assert.GreaterOrEqual(targetPosition1, 0, "Invalid SpeedRST %Max target serialization");
Assert.GreaterOrEqual(targetPosition2, targetPosition1, "SpeedST %Max target serializations don't differ");
// Heart rate targets
BaseHeartRateTarget hrTarget = new BaseHeartRateTarget(placeholderStep);
// HR range
hrTarget.ConcreteTarget = new HeartRateRangeTarget(130, 170, false, hrTarget);
hrTarget.Serialize(database, "HRRangeTarget1", testDocument);
targetPosition1 = testDocument.InnerXml.IndexOf(hrRangeTargetResult1);
Assert.GreaterOrEqual(targetPosition1, 0, "Invalid HRRange target serialization");
hrTarget.ConcreteTarget = new HeartRateRangeTarget(100, 190, false, hrTarget);
hrTarget.Serialize(database, "HRRangeTarget2", testDocument);
targetPosition2 = testDocument.InnerXml.IndexOf(hrRangeTargetResult2);
Assert.GreaterOrEqual(targetPosition2, 0, "Invalid HRRange target serialization");
Assert.Greater(targetPosition2, targetPosition1, "HRRange target serializations don't differ");
hrTarget.ConcreteTarget = new HeartRateRangeTarget(50, 70, true, hrTarget);
hrTarget.Serialize(database, "HRRangeTarget3", testDocument);
targetPosition1 = testDocument.InnerXml.IndexOf(hrRangeTargetResult3);
Assert.GreaterOrEqual(targetPosition1, 0, "Invalid HRRange %Max target serialization");
hrTarget.ConcreteTarget = new HeartRateRangeTarget(75, 95, true, hrTarget);
hrTarget.Serialize(database, "HRRangeTarget4", testDocument);
targetPosition2 = testDocument.InnerXml.IndexOf(hrRangeTargetResult4);
Assert.GreaterOrEqual(targetPosition2, 0, "Invalid HRRange %Max target serialization");
Assert.Greater(targetPosition2, targetPosition1, "HRRange %Max target serializations don't differ");
// HR Garmin zone
hrTarget.ConcreteTarget = new HeartRateZoneGTCTarget(1, hrTarget);
hrTarget.Serialize(database, "HRGTCTarget1", testDocument);
targetPosition1 = testDocument.InnerXml.IndexOf(hrGTCTargetResult1);
Assert.GreaterOrEqual(targetPosition1, 0, "Invalid HRGTC target serialization");
hrTarget.ConcreteTarget = new HeartRateZoneGTCTarget(3, hrTarget);
hrTarget.Serialize(database, "HRGTCTarget2", testDocument);
targetPosition2 = testDocument.InnerXml.IndexOf(hrGTCTargetResult2);
Assert.GreaterOrEqual(targetPosition2, 0, "Invalid HRGTC target serialization");
Assert.Greater(targetPosition2, targetPosition1, "HRGTC target serializations don't differ");
// HR ST zone
Options.Instance.ExportSportTracksHeartRateAsPercentMax = false;
hrTarget.ConcreteTarget = new HeartRateZoneSTTarget(logbook.HeartRateZones[0].Zones[2], hrTarget);
hrTarget.Serialize(database, "HRSTTarget1", testDocument);
targetPosition1 = testDocument.InnerXml.IndexOf(hrSTTargetResult1);
Assert.GreaterOrEqual(targetPosition1, 0, "Invalid HRRST target serialization");
hrTarget.ConcreteTarget = new HeartRateZoneSTTarget(logbook.HeartRateZones[0].Zones[4], hrTarget);
hrTarget.Serialize(database, "HRSTTarget2", testDocument);
targetPosition2 = testDocument.InnerXml.IndexOf(hrSTTargetResult2);
Assert.GreaterOrEqual(targetPosition2, 0, "Invalid HRRST target serialization");
Assert.Greater(targetPosition2, targetPosition1, "HRRST target serializations don't differ");
placeholderWorkout.Category = logbook.ActivityCategories[0].SubCategories[1];
Options.Instance.ExportSportTracksHeartRateAsPercentMax = true;
hrTarget.ConcreteTarget = new HeartRateZoneSTTarget(logbook.HeartRateZones[1].Zones[2], hrTarget);
hrTarget.Serialize(database, "HRSTTarget3", testDocument);
targetPosition1 = testDocument.InnerXml.IndexOf(hrSTTargetResult3);
Assert.GreaterOrEqual(targetPosition1, 0, "Invalid HRRST %Max target serialization");
hrTarget.ConcreteTarget = new HeartRateZoneSTTarget(logbook.HeartRateZones[1].Zones[4], hrTarget);
hrTarget.Serialize(database, "HRSTTarget4", testDocument);
targetPosition2 = testDocument.InnerXml.IndexOf(hrSTTargetResult4);
Assert.GreaterOrEqual(targetPosition1, 0, "Invalid HRRST %Max target serialization");
Assert.GreaterOrEqual(targetPosition2, targetPosition1, "HRST %Max target serializations don't differ");
// Power targets
BasePowerTarget powerTarget = new BasePowerTarget(placeholderStep);
// Power range
powerTarget.ConcreteTarget = new PowerRangeTarget(150, 200, false, powerTarget);
powerTarget.Serialize(database, "PowerRangeTarget1", testDocument);
targetPosition1 = testDocument.InnerXml.IndexOf(powerRangeTargetResult1);
Assert.GreaterOrEqual(targetPosition1, 0, "Invalid PowerRange target serialization");
powerTarget.ConcreteTarget = new PowerRangeTarget(300, 400, false, powerTarget);
powerTarget.Serialize(database, "PowerRangeTarget2", testDocument);
targetPosition2 = testDocument.InnerXml.IndexOf(powerRangeTargetResult2);
Assert.GreaterOrEqual(targetPosition2, 0, "Invalid PowerRange target serialization");
Assert.Greater(targetPosition2, targetPosition1, "PowerRange target serializations don't differ");
powerTarget.ConcreteTarget = new PowerRangeTarget(67, 80, true, powerTarget);
powerTarget.Serialize(database, "PowerRangeTarget3", testDocument);
targetPosition1 = testDocument.InnerXml.IndexOf(powerRangeTargetResult3);
Assert.GreaterOrEqual(targetPosition1, 0, "Invalid PowerRange %FTP target serialization");
powerTarget.ConcreteTarget = new PowerRangeTarget(120, 160, true, powerTarget);
powerTarget.Serialize(database, "PowerRangeTarget4", testDocument);
targetPosition2 = testDocument.InnerXml.IndexOf(powerRangeTargetResult4);
Assert.GreaterOrEqual(targetPosition2, 0, "Invalid PowerRRange %FTP target serialization");
Assert.Greater(targetPosition2, targetPosition1, "PowerRange %FTP target serializations don't differ");
// Power Garmin zone
powerTarget.ConcreteTarget = new PowerZoneGTCTarget(1, powerTarget);
powerTarget.Serialize(database, "PowerGTCTarget1", testDocument);
targetPosition1 = testDocument.InnerXml.IndexOf(powerGTCTargetResult1);
Assert.GreaterOrEqual(targetPosition1, 0, "Invalid PowerGTC target serialization");
powerTarget.ConcreteTarget = new PowerZoneGTCTarget(3, powerTarget);
powerTarget.Serialize(database, "PowerGTCTarget2", testDocument);
targetPosition2 = testDocument.InnerXml.IndexOf(powerGTCTargetResult2);
Assert.GreaterOrEqual(targetPosition2, 0, "Invalid PowerGTC target serialization");
Assert.Greater(targetPosition2, targetPosition1, "PowerGTC target serializations don't differ");
// Power ST zone
placeholderWorkout.Category = logbook.ActivityCategories[0].SubCategories[4];
Options.Instance.ExportSportTracksPowerAsPercentFTP = false;
powerTarget.ConcreteTarget = new PowerZoneSTTarget(logbook.PowerZones[0].Zones[1], powerTarget);
powerTarget.Serialize(database, "PowerSTTarget1", testDocument);
targetPosition1 = testDocument.InnerXml.IndexOf(powerSTTargetResult1);
Assert.GreaterOrEqual(targetPosition1, 0, "Invalid PowerST target serialization");
powerTarget.ConcreteTarget = new PowerZoneSTTarget(logbook.PowerZones[0].Zones[3], powerTarget);
powerTarget.Serialize(database, "PowerSTTarget2", testDocument);
targetPosition2 = testDocument.InnerXml.IndexOf(powerSTTargetResult2);
Assert.GreaterOrEqual(targetPosition2, 0, "Invalid PowerST target serialization");
Assert.Greater(targetPosition2, targetPosition1, "PowerST target serializations don't differ");
Options.Instance.ExportSportTracksPowerAsPercentFTP = true;
powerTarget.ConcreteTarget = new PowerZoneSTTarget(logbook.PowerZones[0].Zones[1], powerTarget);
powerTarget.Serialize(database, "PowerSTTarget3", testDocument);
targetPosition1 = testDocument.InnerXml.IndexOf(powerSTTargetResult3);
Assert.GreaterOrEqual(targetPosition1, 0, "Invalid PowerST %FTP target serialization");
powerTarget.ConcreteTarget = new PowerZoneSTTarget(logbook.PowerZones[0].Zones[3], powerTarget);
powerTarget.Serialize(database, "PowerSTTarget4", testDocument);
targetPosition2 = testDocument.InnerXml.IndexOf(powerSTTargetResult4);
Assert.GreaterOrEqual(targetPosition1, 0, "Invalid PowerST %FTP target serialization");
Assert.GreaterOrEqual(targetPosition2, targetPosition1, "PowerST %FTP target serializations don't differ");
// Make sure to reset options to previous values
Options.Instance.ExportSportTracksHeartRateAsPercentMax = exportHRAsMax;
Options.Instance.ExportSportTracksPowerAsPercentFTP = exportPowerAsFTP;
}
public SpeedRangeTarget(Stream stream, DataVersion version, BaseSpeedTarget baseTarget)
: this(baseTarget)
{
Deserialize(stream, version);
}
public SpeedRangeTarget(BaseSpeedTarget baseTarget)
: base(SpeedTargetType.Range, baseTarget)
{
SetRangeInBaseUnitsPerHour(15, 25);
}
private static string FormatSpeedTarget(BaseSpeedTarget.IConcreteSpeedTarget target)
{
string result;
string baseString;
BaseSpeedTarget.IConcreteSpeedTarget.SpeedTargetType type = target.Type;
FieldInfo fieldInfo = type.GetType().GetField(Enum.GetName(type.GetType(), type));
StepDescriptionStringProviderAttribute providerAttribute = (StepDescriptionStringProviderAttribute)Attribute.GetCustomAttribute(fieldInfo, typeof(StepDescriptionStringProviderAttribute));
baseString = GarminFitnessView.GetLocalizedString(providerAttribute.StringName);
switch (type)
{
case BaseSpeedTarget.IConcreteSpeedTarget.SpeedTargetType.Range:
{
SpeedRangeTarget concreteTarget = (SpeedRangeTarget)target;
if (concreteTarget.BaseTarget.ParentStep.ParentConcreteWorkout.Category.SpeedUnits == Speed.Units.Pace)
{
baseString = GarminFitnessView.GetLocalizedString("PaceRangeTargetDescriptionText");
double min = concreteTarget.GetMinSpeedInMinutesPerBaseUnit();
double max = concreteTarget.GetMaxSpeedInMinutesPerBaseUnit();
UInt16 minMinutes, minSeconds;
UInt16 maxMinutes, maxSeconds;
Utils.DoubleToTime(min, out minMinutes, out minSeconds);
Utils.DoubleToTime(max, out maxMinutes, out maxSeconds);
result = String.Format(baseString,
maxMinutes, maxSeconds,
minMinutes, minSeconds,
Length.LabelAbbr(concreteTarget.BaseUnit));
}
else
{
result = String.Format(baseString, concreteTarget.GetMinSpeedInBaseUnitsPerHour(), concreteTarget.GetMaxSpeedInBaseUnitsPerHour(), Length.LabelAbbr(concreteTarget.BaseUnit));
}
break;
}
case BaseSpeedTarget.IConcreteSpeedTarget.SpeedTargetType.ZoneGTC:
{
SpeedZoneGTCTarget concreteTarget = (SpeedZoneGTCTarget)target;
GarminCategories garminCategory = Options.Instance.GetGarminCategory(target.BaseTarget.ParentStep.ParentWorkout.Category);
GarminActivityProfile currentProfile = GarminProfileManager.Instance.GetProfileForActivity(garminCategory);
result = String.Format(baseString, currentProfile.GetSpeedZoneName(concreteTarget.Zone - 1));
break;
}
case BaseSpeedTarget.IConcreteSpeedTarget.SpeedTargetType.ZoneST:
{
SpeedZoneSTTarget concreteTarget = (SpeedZoneSTTarget)target;
result = String.Format(baseString, concreteTarget.Zone.Name);
break;
}
default:
{
Debug.Assert(false);
result = String.Empty;
break;
}
}
return result;
}
public SpeedZoneGTCTarget(Byte zone, BaseSpeedTarget baseTarget)
: this(baseTarget)
{
Zone = zone;
}
public SpeedZoneGTCTarget(BaseSpeedTarget baseTarget)
: base(SpeedTargetType.ZoneGTC, baseTarget)
{
}
public IConcreteSpeedTarget(SpeedTargetType type, BaseSpeedTarget baseTarget)
{
Debug.Assert(type != SpeedTargetType.SpeedTargetTypeCount);
m_Type = type;
m_BaseTarget = baseTarget;
}
private void BuildSpeedComboBox(BaseSpeedTarget target)
{
BaseSpeedTarget.IConcreteSpeedTarget.SpeedTargetType type = target.ConcreteTarget.Type;
ZoneComboBox.Items.Clear();
ZoneComboBox.Items.Add(GarminFitnessView.GetLocalizedString("CustomText"));
// Use GTC zones
if (type == BaseSpeedTarget.IConcreteSpeedTarget.SpeedTargetType.ZoneGTC ||
(type == BaseSpeedTarget.IConcreteSpeedTarget.SpeedTargetType.Range && !Options.Instance.UseSportTracksHeartRateZones))
{
GarminCategories garminCategory = Options.Instance.GetGarminCategory(target.ParentStep.ParentConcreteWorkout.Category);
GarminActivityProfile currentProfile = GarminProfileManager.Instance.GetProfileForActivity(garminCategory);
for (byte i = 0; i < Constants.GarminSpeedZoneCount; ++i)
{
ZoneComboBox.Items.Add(currentProfile.GetSpeedZoneName(i));
}
}
// Use ST zones
else
{
IList<INamedLowHighZone> zones = target.ParentStep.ParentConcreteWorkout.Category.SpeedZone.Zones;
for (byte i = 0; i < zones.Count; ++i)
{
ZoneComboBox.Items.Add(zones[i].Name);
}
}
}
public SpeedZoneSTTarget(INamedLowHighZone zone, BaseSpeedTarget baseTarget)
: this(baseTarget)
{
Zone = zone;
}