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 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 static ITarget Create(FITMessage stepMessage, RegularStep parent)
{
FITMessageField targetTypeField = stepMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetType);
FITMessageField targetField = stepMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetValue);
FITMessageField targetCustomLowField = stepMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetCustomValueLow);
FITMessageField targetCustomHighField = stepMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetCustomValueHigh);
ITarget result = new NullTarget(parent);
if(targetTypeField != null)
{
switch((FITWorkoutStepTargetTypes)targetTypeField.GetEnum())
{
case FITWorkoutStepTargetTypes.HeartRate:
{
if(targetField != null)
{
BaseHeartRateTarget hrTarget = (BaseHeartRateTarget)Create(ITarget.TargetType.HeartRate, parent);
UInt32 hrZone = targetField.GetUInt32();
if (hrZone == 0)
{
if (targetCustomLowField != null &&
targetCustomHighField != null)
{
HeartRateRangeTarget concreteTarget = new HeartRateRangeTarget(hrTarget);
if (targetCustomLowField.GetUInt32() > 100)
{
concreteTarget.SetValues((Byte)(targetCustomLowField.GetUInt32() - 100),
(Byte)(targetCustomHighField.GetUInt32() - 100),
false);
}
else
{
concreteTarget.SetValues((Byte)targetCustomLowField.GetUInt32(),
(Byte)targetCustomHighField.GetUInt32(),
true);
}
hrTarget.ConcreteTarget = concreteTarget;
}
else
{
throw new FITParserException("Missing target custom value field");
}
}
else
{
HeartRateZoneGTCTarget concreteTarget = new HeartRateZoneGTCTarget(hrTarget);
concreteTarget.Zone = (Byte)hrZone;
hrTarget.ConcreteTarget = concreteTarget;
}
result = hrTarget;
}
else
{
throw new FITParserException("Missing target value field");
}
break;
}
case FITWorkoutStepTargetTypes.Cadence:
{
if (targetField != null &&
targetCustomLowField != null &&
targetCustomHighField != null)
{
BaseCadenceTarget cadenceTarget = (BaseCadenceTarget)Create(ITarget.TargetType.Cadence, parent);
CadenceRangeTarget concreteTarget = new CadenceRangeTarget(cadenceTarget);
UInt32 cadenceZone = targetField.GetUInt32();
Debug.Assert(cadenceZone == 0);
concreteTarget.SetValues((Byte)targetCustomLowField.GetUInt32(),
(Byte)targetCustomHighField.GetUInt32());
cadenceTarget.ConcreteTarget = concreteTarget;
result = cadenceTarget;
}
else
{
throw new FITParserException("Missing target or custom values field");
}
break;
}
case FITWorkoutStepTargetTypes.Speed:
{
if(targetField != null)
{
BaseSpeedTarget speedTarget = (BaseSpeedTarget)Create(ITarget.TargetType.Speed, parent);
UInt32 speedZone = targetField.GetUInt32();
if (speedZone == 0)
{
if (targetCustomLowField != null &&
targetCustomHighField != null)
{
SpeedRangeTarget concreteTarget = new SpeedRangeTarget(speedTarget);
concreteTarget.SetRangeInBaseUnitsPerHour(Length.Convert(targetCustomLowField.GetUInt32() * 3.6, Length.Units.Meter, concreteTarget.BaseUnit),
Length.Convert(targetCustomHighField.GetUInt32() * 3.6, Length.Units.Meter, concreteTarget.BaseUnit));
speedTarget.ConcreteTarget = concreteTarget;
}
else
{
throw new FITParserException("Missing target custom value field");
}
}
else
{
SpeedZoneGTCTarget concreteTarget = new SpeedZoneGTCTarget(speedTarget);
concreteTarget.Zone = (Byte)speedZone;
speedTarget.ConcreteTarget = concreteTarget;
}
result = speedTarget;
}
else
{
throw new FITParserException("Missing target value field");
}
break;
}
case FITWorkoutStepTargetTypes.Power:
{
if(targetField != null)
{
BasePowerTarget powerTarget = (BasePowerTarget)Create(ITarget.TargetType.Power, parent);
UInt32 powerZone = targetField.GetUInt32();
if (powerZone == 0)
{
if (targetCustomLowField != null &&
targetCustomHighField != null)
{
PowerRangeTarget concreteTarget = new PowerRangeTarget(powerTarget);
if (targetCustomLowField.GetUInt32() > 1000)
{
concreteTarget.SetValues((UInt16)(targetCustomLowField.GetUInt32() - 1000),
(UInt16)(targetCustomHighField.GetUInt32() - 1000),
false);
}
else
{
concreteTarget.SetValues((UInt16)(targetCustomLowField.GetUInt32()),
(UInt16)(targetCustomHighField.GetUInt32()),
true);
}
powerTarget.ConcreteTarget = concreteTarget;
}
else
{
throw new FITParserException("Missing target custom value field");
}
}
else
{
PowerZoneGTCTarget concreteTarget = new PowerZoneGTCTarget(powerTarget);
concreteTarget.Zone = (Byte)powerZone;
powerTarget.ConcreteTarget = concreteTarget;
}
result = powerTarget;
}
else
{
throw new FITParserException("Missing target value field");
}
break;
}
}
}
else
{
throw new FITParserException("Missing target type field");
}
return result;
}
public RegularStep(Workout parent)
: base(StepType.Regular, parent)
{
Duration = new LapButtonDuration(this);
Target = new NullTarget(this);
}