public RepeatUntilPowerBelowDuration(UInt16 minPower, bool isPercentFTP, RepeatStep parent)
: this(parent)
{
ValidateValue(minPower, isPercentFTP);
MinPower = minPower;
IsPercentFTP = isPercentFTP;
}
public RepeatUntilHeartRateAboveDuration(Byte maxHeartRate, bool isPercentageMaxHeartRate, RepeatStep parent)
: this(parent)
{
ValidateValue(maxHeartRate, isPercentageMaxHeartRate);
MaxHeartRate = maxHeartRate;
IsPercentageMaxHeartRate = isPercentageMaxHeartRate;
}
public RepeatUntilPowerAboveDuration(UInt16 maxPower, bool isPercentFTP, RepeatStep parent)
: this(parent)
{
ValidateValue(maxPower, isPercentFTP);
MaxPower = maxPower;
IsPercentFTP = isPercentFTP;
}
public RepeatUntilHeartRateBelowDuration(Byte minHeartRate, bool isPercentageMaxHeartRate, RepeatStep parent)
: this(parent)
{
ValidateValue(minHeartRate, isPercentageMaxHeartRate);
MinHeartRate = minHeartRate;
IsPercentageMaxHeartRate = isPercentageMaxHeartRate;
}
public static IRepeatDuration Create(IRepeatDuration.RepeatDurationType type, RepeatStep parent)
{
IRepeatDuration newDuration;
switch (type)
{
case IRepeatDuration.RepeatDurationType.RepeatCount:
{
newDuration = new RepeatCountDuration(parent);
break;
}
case IRepeatDuration.RepeatDurationType.RepeatUntilTime:
{
newDuration = new RepeatUntilTimeDuration(parent);
break;
}
case IRepeatDuration.RepeatDurationType.RepeatUntilDistance:
{
newDuration = new RepeatUntilDistanceDuration(parent);
break;
}
case IRepeatDuration.RepeatDurationType.RepeatUntilHeartRateAbove:
{
newDuration = new RepeatUntilHeartRateAboveDuration(parent);
break;
}
case IRepeatDuration.RepeatDurationType.RepeatUntilHeartRateBelow:
{
newDuration = new RepeatUntilHeartRateBelowDuration(parent);
break;
}
case IRepeatDuration.RepeatDurationType.RepeatUntilCalories:
{
newDuration = new RepeatUntilCaloriesDuration(parent);
break;
}
case IRepeatDuration.RepeatDurationType.RepeatUntilPowerAbove:
{
newDuration = new RepeatUntilPowerAboveDuration(parent);
break;
}
case IRepeatDuration.RepeatDurationType.RepeatUntilPowerBelow:
{
newDuration = new RepeatUntilPowerBelowDuration(parent);
break;
}
default:
{
Debug.Assert(false);
newDuration = null;
break;
}
}
parent.Duration = newDuration;
return newDuration;
}
void OnRepeatDurationChanged(RepeatStep modifiedStep, IRepeatDuration durationChanged, PropertyChangedEventArgs changedProperty)
{
if (ConcreteWorkout.StepRepeatDurationChanged != null)
{
ConcreteWorkout.StepRepeatDurationChanged(this, modifiedStep, durationChanged, changedProperty);
}
}
public RepeatUntilDistanceDuration(Stream stream, DataVersion version, RepeatStep parent)
: this(parent)
{
Deserialize(stream, version);
}
public RepeatUntilDistanceDuration(RepeatStep parent)
: base(RepeatDurationType.RepeatUntilDistance, parent)
{
SetDistanceInBaseUnit(1);
}
protected IRepeatDuration(RepeatDurationType type, RepeatStep parent)
{
Debug.Assert(type != RepeatDurationType.RepeatDurationTypeCount);
m_Type = type;
m_ParentStep = parent;
}
void OnWorkoutStepsChanged(IStep addedRemovedStep)
{
if (addedRemovedStep == this)
{
m_CurrentTopMostRepeat = ParentConcreteWorkout.Steps.GetTopMostRepeatForStep(this);
}
UpdateWorkoutStepsCopy();
}
public void TestRepeatStepFITDeserialization()
{
Workout placeholderWorkout = new Workout("Test", PluginMain.GetApplication().Logbook.ActivityCategories[0]);
RegularStep regularStep;
RepeatStep repeatStep = new RepeatStep(placeholderWorkout);
FITMessage serializedMessage = new FITMessage(FITGlobalMessageIds.WorkoutStep);
FITMessageField durationValueField = new FITMessageField((Byte)FITWorkoutStepFieldIds.DurationValue);
FITMessageField durationTypeField = new FITMessageField((Byte)FITWorkoutStepFieldIds.DurationType);
FITMessageField targetValueField = new FITMessageField((Byte)FITWorkoutStepFieldIds.TargetValue);
regularStep = placeholderWorkout.Steps[0] as RegularStep;
// Setup message
serializedMessage.AddField(durationValueField);
serializedMessage.AddField(durationTypeField);
serializedMessage.AddField(targetValueField);
durationValueField.SetUInt32(0); // Step id to start repeat at
durationTypeField.SetEnum((Byte)FITWorkoutStepDurationTypes.RepeatCount);
targetValueField.SetUInt32(2);
// This test is a little hard to follow because repeat steps in FIT format regroup previously deserialized steps.
// We will illustrate the expected output throughout the test to ease validation.
// At this point we have the following
// - Root
// - Regular step (id = 0)
// By deserializing the message we should get the following
// - Root
// - Repeat step (id = 1)
// - Regular step (id = 0)
repeatStep.DeserializeFromFIT(serializedMessage);
placeholderWorkout.Steps.AddStepToRoot(repeatStep);
Assert.AreEqual(1, placeholderWorkout.Steps.Count, "Incorrect number of steps in workout after FIT deserialization of repeat step with single child");
Assert.AreEqual(2, placeholderWorkout.StepCount, "Incorrect number of steps in workout after FIT deserialization of repeat step with single child");
Assert.IsTrue(placeholderWorkout.Steps[0] is RepeatStep, "Invalid workout structure after FIT deserialization of repeat step with single child");
Assert.AreEqual(repeatStep, placeholderWorkout.Steps[0], "Invalid workout structure after FIT deserialization of repeat step with single child");
Assert.AreEqual(1, repeatStep.StepsToRepeat.Count, "Invalid number of children in repeat after FIT deserialization of repeat step with single child");
Assert.AreEqual(regularStep, repeatStep.StepsToRepeat[0], "Invalid child in repeat after FIT deserialization of repeat step with single child");
placeholderWorkout.Steps.AddStepToRoot(new RegularStep(placeholderWorkout));
placeholderWorkout.Steps.AddStepToRoot(new RegularStep(placeholderWorkout));
repeatStep = new RepeatStep(placeholderWorkout);
durationValueField.SetUInt32(2); // Step id to start repeat at
// At this point we have the following
// - Root
// - Repeat step (id = 1)
// - Regular step (id = 0)
// - Regular step (id = 2)
// - Regular step (id = 3)
// By deserializing the message we should get the following
// - Root
// - Repeat step (id = 1)
// - Regular step (id = 0)
// - Repeat step (id = 4)
// - Regular step (id = 2)
// - Regular step (id = 3)
repeatStep.DeserializeFromFIT(serializedMessage);
placeholderWorkout.Steps.AddStepToRoot(repeatStep);
Assert.AreEqual(2, placeholderWorkout.Steps.Count, "Incorrect number of steps in workout after FIT deserialization of repeat step with multiple children");
Assert.AreEqual(5, placeholderWorkout.StepCount, "Incorrect number of steps in workout after FIT deserialization of repeat step with multiple children");
Assert.IsTrue(placeholderWorkout.Steps[1] is RepeatStep, "Invalid workout structure after FIT deserialization of repeat step with multiple children");
Assert.AreEqual(repeatStep, placeholderWorkout.Steps[1], "Invalid workout structure after FIT deserialization of repeat step with multiple children");
Assert.AreEqual(2, repeatStep.StepsToRepeat.Count, "Invalid number of children in repeat after FIT deserialization of repeat step with multiple children");
Assert.IsTrue(placeholderWorkout.Steps[0] is RepeatStep, "Invalid repeat step structure after FIT deserialization of repeat step with multiple children");
Assert.IsTrue(placeholderWorkout.Steps[1] is RepeatStep, "Invalid repeat step structure after FIT deserialization of repeat step with multiple children");
regularStep = new RegularStep(placeholderWorkout);
placeholderWorkout.Steps.InsertStepBeforeStep(regularStep, placeholderWorkout.Steps[0]);
repeatStep = new RepeatStep(placeholderWorkout);
durationValueField.SetUInt32(1); // Step id to start repeat at
// At this point we have the following
// - Root
// - Regular step (id = 0)
// - Repeat step (id = 2)
// - Regular step (id = 1)
// - Repeat step (id = 5)
// - Regular step (id = 4)
// - Regular step (id = 5)
// - Repeat step (not deserialized yet)
// By deserializing the message we should get the following
// - Root
// - Regular step (id = 0)
// - Repeat step (id = 6)
// - Repeat step (id = 2)
// - Regular step (id = 1)
// - Repeat step (id = 5)
// - Regular step (id = 3)
// - Regular step (id = 4)
repeatStep.DeserializeFromFIT(serializedMessage);
placeholderWorkout.Steps.AddStepToRoot(repeatStep);
Assert.AreEqual(2, placeholderWorkout.Steps.Count, "Incorrect number of steps in workout after FIT deserialization of repeat step with multiple nested children");
Assert.AreEqual(7, placeholderWorkout.StepCount, "Incorrect number of steps in workout after FIT deserialization of repeat step with multiple nested children");
Assert.IsTrue(placeholderWorkout.Steps[0] is RegularStep, "Invalid workout structure after FIT deserialization of repeat step with multiple nested children");
Assert.IsTrue(placeholderWorkout.Steps[1] is RepeatStep, "Invalid workout structure after FIT deserialization of repeat step with multiple nested children");
Assert.AreEqual(regularStep, placeholderWorkout.Steps[0], "Invalid workout structure after FIT deserialization of repeat step with multiple nested children");
Assert.AreEqual(repeatStep, placeholderWorkout.Steps[1], "Invalid workout structure after FIT deserialization of repeat step with multiple nested children");
Assert.AreEqual(2, repeatStep.StepsToRepeat.Count, "Invalid number of children in repeat after FIT deserialization of repeat step with multiple nested children");
Assert.IsTrue(repeatStep.StepsToRepeat[0] is RepeatStep, "Invalid repeat step structure after FIT deserialization of repeat step with multiple nested children");
Assert.IsTrue(repeatStep.StepsToRepeat[1] is RepeatStep, "Invalid repeat step structure after FIT deserialization of repeat step with multiple nested children");
}
public RepeatCountDuration(Stream stream, DataVersion version, RepeatStep parent)
: this(parent)
{
Deserialize(stream, version);
}
public RepeatCountDuration(RepeatStep parent)
: base(RepeatDurationType.RepeatCount, parent)
{
}
public static IRepeatDuration Create(FITMessage stepMessage, RepeatStep parent)
{
FITMessageField durationTypeField = stepMessage.GetField((Byte)FITWorkoutStepFieldIds.DurationType);
FITMessageField targetField = stepMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetValue);
IRepeatDuration newDuration = new RepeatCountDuration(parent);
if (durationTypeField == null)
{
throw new FITParserException("Missing repeat duration type field");
}
else if (targetField == null)
{
throw new FITParserException("Missing repeat target value field");
}
else
{
switch ((FITWorkoutStepDurationTypes)durationTypeField.GetEnum())
{
case FITWorkoutStepDurationTypes.RepeatCount:
{
RepeatCountDuration repeatDuration = (RepeatCountDuration)Create(IRepeatDuration.RepeatDurationType.RepeatCount, parent);
repeatDuration.RepetitionCount = (Byte)targetField.GetUInt32();
newDuration = repeatDuration;
break;
}
case FITWorkoutStepDurationTypes.RepeatUntilTime:
{
RepeatUntilTimeDuration timeDuration = Create(IRepeatDuration.RepeatDurationType.RepeatUntilTime, parent) as RepeatUntilTimeDuration;
timeDuration.TimeInSeconds = (UInt16)(targetField.GetUInt32() / 1000.0f);
newDuration = timeDuration;
break;
}
case FITWorkoutStepDurationTypes.RepeatUntilDistance:
{
RepeatUntilDistanceDuration distanceDuration = Create(IRepeatDuration.RepeatDurationType.RepeatUntilDistance, parent) as RepeatUntilDistanceDuration;
distanceDuration.SetDistanceInBaseUnit(Length.Convert(targetField.GetUInt32(), Length.Units.Centimeter, distanceDuration.BaseUnit));
newDuration = distanceDuration;
break;
}
case FITWorkoutStepDurationTypes.RepeatUntilHeartRateGreaterThan:
{
RepeatUntilHeartRateAboveDuration hrDuration = Create(IRepeatDuration.RepeatDurationType.RepeatUntilHeartRateAbove, parent) as RepeatUntilHeartRateAboveDuration;
UInt32 hrValue = targetField.GetUInt32();
if (hrValue >= 100)
{
hrDuration.IsPercentageMaxHeartRate = false;
hrDuration.MaxHeartRate = (Byte)(hrValue - 100);
}
else
{
hrDuration.IsPercentageMaxHeartRate = true;
hrDuration.MaxHeartRate = (Byte)hrValue;
}
newDuration = hrDuration;
break;
}
case FITWorkoutStepDurationTypes.RepeatUntilHeartRateLessThan:
{
RepeatUntilHeartRateBelowDuration hrDuration = Create(IRepeatDuration.RepeatDurationType.RepeatUntilHeartRateBelow, parent) as RepeatUntilHeartRateBelowDuration;
UInt32 hrValue = targetField.GetUInt32();
if (hrValue >= 100)
{
hrDuration.IsPercentageMaxHeartRate = false;
hrDuration.MinHeartRate = (Byte)(hrValue - 100);
}
else
{
hrDuration.IsPercentageMaxHeartRate = true;
hrDuration.MinHeartRate = (Byte)hrValue;
}
newDuration = hrDuration;
break;
}
case FITWorkoutStepDurationTypes.RepeatUntilCalories:
{
RepeatUntilCaloriesDuration caloriesDuration = Create(IRepeatDuration.RepeatDurationType.RepeatUntilCalories, parent) as RepeatUntilCaloriesDuration;
caloriesDuration.CaloriesToSpend = (UInt16)targetField.GetUInt32();
newDuration = caloriesDuration;
break;
}
case FITWorkoutStepDurationTypes.RepeatUntilPowerGreaterThan:
{
RepeatUntilPowerAboveDuration powerDuration = Create(IRepeatDuration.RepeatDurationType.RepeatUntilPowerAbove, parent) as RepeatUntilPowerAboveDuration;
UInt32 powerValue = targetField.GetUInt32();
if (powerValue >= 1000)
{
powerDuration.IsPercentFTP = false;
powerDuration.MaxPower = (UInt16)(powerValue - 1000);
}
else
{
powerDuration.IsPercentFTP = true;
powerDuration.MaxPower = (UInt16)powerValue;
}
newDuration = powerDuration;
break;
}
case FITWorkoutStepDurationTypes.RepeatUntilPowerLessThan:
{
RepeatUntilPowerBelowDuration powerDuration = Create(IRepeatDuration.RepeatDurationType.RepeatUntilPowerBelow, parent) as RepeatUntilPowerBelowDuration;
UInt32 powerValue = targetField.GetUInt32();
if (powerValue >= 1000)
{
powerDuration.IsPercentFTP = false;
powerDuration.MinPower = (UInt16)(powerValue - 1000);
}
else
{
powerDuration.IsPercentFTP = true;
powerDuration.MinPower = (UInt16)powerValue;
}
newDuration = powerDuration;
break;
}
}
}
parent.Duration = newDuration;
return newDuration;
}
public RepeatUntilTimeDuration(UInt16 timeInSeconds, RepeatStep parent)
: this(parent)
{
TimeInSeconds = timeInSeconds;
}
public void TestTCXSerialization()
{
XmlDocument testDocument = new XmlDocument();
XmlNode database;
XmlAttribute attribute;
Workout placeholderWorkout = new Workout("Test", PluginMain.GetApplication().Logbook.ActivityCategories[0]);
RepeatStep placeholderStep = new RepeatStep(placeholderWorkout);
// 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);
// Repeat count
RepeatCountDuration countDuration = new RepeatCountDuration(placeholderStep);
placeholderStep.Duration = countDuration;
countDuration.RepetitionCount = 4;
countDuration.Serialize(database, "RepeatCountDuration1", testDocument);
int durationPosition1 = testDocument.InnerXml.IndexOf(repeatCountDurationResult1);
Assert.GreaterOrEqual(durationPosition1, 0, "Invalid repeat count duration serialization");
countDuration.RepetitionCount = 10;
countDuration.Serialize(database, "RepeatCountDuration2", testDocument);
int durationPosition2 = testDocument.InnerXml.IndexOf(repeatCountDurationResult2);
Assert.GreaterOrEqual(durationPosition2, 0, "Invalid repeat count duration serialization");
Assert.Greater(durationPosition2, durationPosition1, "Repeat count durations serialization don't differ");
// All other repeat durtions should not serialize in TCX
try
{
RepeatUntilCaloriesDuration caloriesDuration = new RepeatUntilCaloriesDuration(placeholderStep);
caloriesDuration.Serialize(database, "RepeatUntilCaloriesDuration", testDocument);
Assert.Fail("Repeat until calories should not serialize");
}
catch (NotSupportedException)
{
}
try
{
RepeatUntilDistanceDuration distanceDuration = new RepeatUntilDistanceDuration(placeholderStep);
distanceDuration.Serialize(database, "RepeatUntilDistanceDuration", testDocument);
Assert.Fail("Repeat until distance should not serialize");
}
catch (NotSupportedException)
{
}
try
{
RepeatUntilHeartRateAboveDuration hrAboveDuration = new RepeatUntilHeartRateAboveDuration(placeholderStep);
hrAboveDuration.Serialize(database, "RepeatUntilHRAboveDuration", testDocument);
Assert.Fail("Repeat until HRAbove should not serialize");
}
catch (NotSupportedException)
{
}
try
{
RepeatUntilHeartRateBelowDuration hrBelowDuration = new RepeatUntilHeartRateBelowDuration(placeholderStep);
hrBelowDuration.Serialize(database, "RepeatUntilHRBelowDuration", testDocument);
Assert.Fail("Repeat until HRBelow should not serialize");
}
catch (NotSupportedException)
{
}
try
{
RepeatUntilPowerAboveDuration powerAboveDuration = new RepeatUntilPowerAboveDuration(placeholderStep);
powerAboveDuration.Serialize(database, "RepeatUntilPowerAboveDuration", testDocument);
Assert.Fail("Repeat until PowerAbove should not serialize");
}
catch (NotSupportedException)
{
}
try
{
RepeatUntilPowerBelowDuration powerBelowDuration = new RepeatUntilPowerBelowDuration(placeholderStep);
powerBelowDuration.Serialize(database, "RepeatUntilPowerBelowDuration", testDocument);
Assert.Fail("Repeat until PowerBelow should not serialize");
}
catch (NotSupportedException)
{
}
try
{
RepeatUntilTimeDuration timeDuration = new RepeatUntilTimeDuration(placeholderStep);
timeDuration.Serialize(database, "RepeatUntilTimeDuration", testDocument);
Assert.Fail("Repeat until time should not serialize");
}
catch (NotSupportedException)
{
}
try
{
RepeatUntilCaloriesDuration caloriesDuration = new RepeatUntilCaloriesDuration(placeholderStep);
caloriesDuration.Serialize(database, "RepeatUntilCaloriesDuration", testDocument);
Assert.Fail("Repeat until calories should not serialize");
}
catch (NotSupportedException)
{
}
}
private void Initialize()
{
m_WorkoutStepsCopy = new WorkoutStepsList(ParentConcreteWorkout);
LinkedWorkout.WorkoutChanged += new IWorkout.WorkoutChangedEventHandler(OnWorkoutChanged);
LinkedWorkout.StepChanged += new IWorkout.StepChangedEventHandler(OnWorkoutStepChanged);
LinkedWorkout.StepDurationChanged += new IWorkout.StepDurationChangedEventHandler(OnWorkoutStepDurationChanged);
LinkedWorkout.StepTargetChanged += new IWorkout.StepTargetChangedEventHandler(OnWorkoutStepTargetChanged);
LinkedWorkout.Steps.StepAdded += new WorkoutStepsList.StepAddedEventHandler(OnWorkoutStepsChanged);
LinkedWorkout.Steps.StepRemoved += new WorkoutStepsList.StepRemovedEventHandler(OnWorkoutStepsChanged);
LinkedWorkout.Steps.ListChanged += new PropertyChangedEventHandler(OnWorkoutStepsListChanged);
UpdateWorkoutStepsCopy();
m_CurrentTopMostRepeat = ParentConcreteWorkout.Steps.GetTopMostRepeatForStep(this);
}
public void TestRepeatStepFITSerialization()
{
Workout placeholderWorkout = new Workout("Test", PluginMain.GetApplication().Logbook.ActivityCategories[0]);
RepeatStep repeatStep = new RepeatStep(placeholderWorkout);
FITMessage serializedMessage = new FITMessage(FITGlobalMessageIds.WorkoutStep);
FITMessageField messageField;
placeholderWorkout.Steps.AddStepToRoot(repeatStep);
placeholderWorkout.Steps.RemoveStep(placeholderWorkout.Steps[0]);
// Single child
// - Root
// - Repeat step (id = 1)
// - Regular step (id = 0)
repeatStep.FillFITStepMessage(serializedMessage);
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.DurationValue);
Assert.IsNotNull(messageField, "Duration value field not serialized for repeat step");
Assert.AreEqual(0, messageField.GetUInt32(), "Invalid duration value FIT serialization for repeat step with single child");
serializedMessage.Clear();
// Multiple children
// - Root
// - Repeat step (id = 2)
// - Regular step (id = 0)
// - Regular step (id = 1)
repeatStep.StepsToRepeat.Add(new RegularStep(placeholderWorkout));
repeatStep.FillFITStepMessage(serializedMessage);
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.DurationValue);
Assert.IsNotNull(messageField, "Duration value field not serialized for repeat step");
Assert.AreEqual(0, messageField.GetUInt32(), "Invalid duration value FIT serialization for repeat step with single child");
serializedMessage.Clear();
// Nested repeat steps
// - Repeat step (id = 4)
// - Regular step (id = 0)
// - Regular step (id = 1)
// - Repeat step (id = 3)
// - Regular step (id = 2)
repeatStep.StepsToRepeat.Add(new RepeatStep(placeholderWorkout));
repeatStep.StepsToRepeat[2].FillFITStepMessage(serializedMessage);
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.DurationValue);
Assert.IsNotNull(messageField, "Duration value field not serialized for repeat step");
Assert.AreEqual(2, messageField.GetUInt32(), "Invalid duration value FIT serialization for repeat step with single child");
serializedMessage.Clear();
// Nested repeats with 2nd repeat as first nested step
// - Root
// - Repeat step (id = 4)
// - Regular step (id = 0)
// - Regular step (id = 1)
// - Repeat step (id = 3)
// - Regular step (id = 2)
// - Repeat step (id = 8)
// - Repeat step (id = 6)
// - Regular step (id = 5)
// - Regular step (id = 7)
repeatStep = new RepeatStep(placeholderWorkout);
placeholderWorkout.Steps.AddStepToRoot(repeatStep);
repeatStep.StepsToRepeat.Insert(0, new RepeatStep(placeholderWorkout));
repeatStep.FillFITStepMessage(serializedMessage);
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.DurationValue);
Assert.IsNotNull(messageField, "Duration value field not serialized for repeat step");
Assert.AreEqual(5, messageField.GetUInt32(), "Invalid duration value FIT serialization for repeat step with single child");
serializedMessage.Clear();
}
void OnWorkoutStepsListChanged(object sender, PropertyChangedEventArgs args)
{
if (sender == ParentConcreteWorkout.Steps)
{
RepeatStep newTopMostRepeat = ParentConcreteWorkout.Steps.GetTopMostRepeatForStep(this);
if (newTopMostRepeat != m_CurrentTopMostRepeat)
{
m_CurrentTopMostRepeat = newTopMostRepeat;
UpdateWorkoutStepsCopy();
}
}
else if (sender == LinkedWorkout.Steps)
{
UpdateWorkoutStepsCopy();
}
}
public void TestRepeatStepTCXDeserialization()
{
XmlDocument testDocument = new XmlDocument();
XmlNode readNode;
XmlNode database;
Workout placeholderWorkout = new Workout("Test", PluginMain.GetApplication().Logbook.ActivityCategories[0]);
RepeatStep repeatStep = new RepeatStep(placeholderWorkout);
// Setup document
testDocument.AppendChild(testDocument.CreateXmlDeclaration("1.0", "UTF-8", "no"));
database = testDocument.CreateNode(XmlNodeType.Element, "TrainingCenterDatabase", null);
testDocument.AppendChild(database);
XmlAttribute attribute = testDocument.CreateAttribute("xmlns", "xsi", GarminFitnessPlugin.Constants.xmlns);
attribute.Value = "http://www.w3.org/2001/XMLSchema-instance";
database.Attributes.Append(attribute);
readNode = testDocument.CreateElement("TestNode");
database.AppendChild(readNode);
// Single child
readNode.InnerXml = repeatStepTestResult1;
repeatStep.Deserialize(readNode.FirstChild);
Assert.AreEqual(1, repeatStep.StepsToRepeat.Count, "Invalid step count deserialized for repeat step with single child");
Assert.IsTrue(repeatStep.StepsToRepeat[0] is RegularStep, "Invalid child step deserialized for repeat step with single child");
// Multiple children
readNode.InnerXml = repeatStepTestResult2;
repeatStep.Deserialize(readNode.FirstChild);
Assert.AreEqual(2, repeatStep.StepsToRepeat.Count, "Invalid step count deserialized for repeat step with multiple children");
Assert.IsTrue(repeatStep.StepsToRepeat[0] is RegularStep, "Invalid child step deserialized for repeat step with multiple children");
Assert.IsTrue(repeatStep.StepsToRepeat[1] is RegularStep, "Invalid child step deserialized for repeat step with multiple children");
// Nested repeat step
readNode.InnerXml = repeatStepTestResult3;
repeatStep.Deserialize(readNode.FirstChild);
Assert.AreEqual(3, repeatStep.StepsToRepeat.Count, "Invalid step count deserialized for repeat step with nested repeat child");
Assert.IsTrue(repeatStep.StepsToRepeat[0] is RegularStep, "Invalid child step deserialized for repeat step with nested repeat child");
Assert.IsTrue(repeatStep.StepsToRepeat[1] is RegularStep, "Invalid child step deserialized for repeat step with nested repeat child");
Assert.IsTrue(repeatStep.StepsToRepeat[2] is RepeatStep, "Invalid child step deserialized for repeat step with nested repeat child");
RepeatStep tempRepeat = repeatStep.StepsToRepeat[2] as RepeatStep;
Assert.AreEqual(1, tempRepeat.StepsToRepeat.Count, "Invalid child step deserialized for repeat step with nested repeat child");
Assert.IsTrue(tempRepeat.StepsToRepeat[0] is RegularStep, "Invalid child step deserialized for repeat step with nested repeat child");
// Regular step after repeat
readNode.InnerXml = repeatStepTestResult4;
repeatStep.Deserialize(readNode.FirstChild);
Assert.AreEqual(4, repeatStep.StepsToRepeat.Count, "Invalid step count deserialized for repeat step with step after nested repeat child");
Assert.IsTrue(repeatStep.StepsToRepeat[3] is RegularStep, "Invalid child step deserialized for repeat step with step after nested repeat child");
}
protected IRepeatDuration(Stream stream, DataVersion version, RepeatStep parent)
{
m_ParentStep = parent;
Deserialize(stream, version);
}
public void TestRepeatStepTCXSerialization()
{
XmlDocument testDocument = new XmlDocument();
XmlNode database;
XmlAttribute attribute;
Workout placeholderWorkout = new Workout("Test", PluginMain.GetApplication().Logbook.ActivityCategories[0]);
RepeatStep step = new RepeatStep(placeholderWorkout);
int resultPosition;
placeholderWorkout.Steps.AddStepToRoot(step);
placeholderWorkout.Steps.RemoveStep(placeholderWorkout.Steps[0]);
// 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);
// Single child
step.Serialize(database, "RepeatStepTest1", testDocument);
resultPosition = testDocument.InnerXml.IndexOf(repeatStepTestResult1);
Assert.GreaterOrEqual(resultPosition, 0, "Invalid step TCX serialization for repeat step with single child");
// Multiple children
step.StepsToRepeat.Add(new RegularStep(placeholderWorkout));
step.Serialize(database, "RepeatStepTest2", testDocument);
resultPosition = testDocument.InnerXml.IndexOf(repeatStepTestResult2);
Assert.GreaterOrEqual(resultPosition, 0, "Invalid step TCX serialization for repeat step with multiple children");
// Nested repeat steps
step.StepsToRepeat.Add(new RepeatStep(placeholderWorkout));
step.Serialize(database, "RepeatStepTest3", testDocument);
resultPosition = testDocument.InnerXml.IndexOf(repeatStepTestResult3);
Assert.GreaterOrEqual(resultPosition, 0, "Invalid step TCX serialization for repeat step with nested repeat child");
}
public RepeatUntilDistanceDuration(double distanceToGo, Length.Units distanceUnit, RepeatStep parent)
: this(parent)
{
SetDistanceInUnits(distanceToGo, distanceUnit);
}
public void TestStepNotesTCXSerialization()
{
XmlDocument testDocument = new XmlDocument();
XmlNode database;
XmlAttribute attribute;
Workout placeholderWorkout = new Workout("Test", PluginMain.GetApplication().Logbook.ActivityCategories[0]);
RegularStep regularStep = placeholderWorkout.Steps[0] as RegularStep;
// 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);
// Regular step
regularStep.Notes = "This is a note";
regularStep.Serialize(database, "stepNotesTest", testDocument);
Assert.GreaterOrEqual(placeholderWorkout.STExtensions.Count, 1, "Missing step extension node for regular step note");
Assert.AreEqual(stepNotesExtensionResult1,
placeholderWorkout.STExtensions[placeholderWorkout.STExtensions.Count - 1].OuterXml,
"Invalid step notes serialization");
regularStep.Notes = "This is a new note";
regularStep.Serialize(database, "stepNotesTest", testDocument);
Assert.GreaterOrEqual(placeholderWorkout.STExtensions.Count, 1, "Missing step extension node for regular step note");
Assert.AreEqual(stepNotesExtensionResult2,
placeholderWorkout.STExtensions[placeholderWorkout.STExtensions.Count - 1].OuterXml,
"Invalid step notes serialization");
// Repeat step
RepeatStep repeatStep = new RepeatStep(placeholderWorkout);
placeholderWorkout.Steps.AddStepToRoot(repeatStep);
repeatStep.Notes = "This is a repeat note";
repeatStep.Serialize(database, "stepNotesTest", testDocument);
Assert.GreaterOrEqual(placeholderWorkout.STExtensions.Count, 1, "Missing step extension node for repeat step note");
Assert.AreEqual(stepNotesExtensionResult3,
placeholderWorkout.STExtensions[placeholderWorkout.STExtensions.Count - 2].OuterXml,
"Invalid step notes serialization");
}
public RepeatUntilHeartRateAboveDuration(RepeatStep parent)
: base(RepeatDurationType.RepeatUntilHeartRateAbove, parent)
{
}
public void TestFITSerialization()
{
Workout placeholderWorkout = new Workout("Test", PluginMain.GetApplication().Logbook.ActivityCategories[0]);
RepeatStep placeholderStep = new RepeatStep(placeholderWorkout);
FITMessage serializedMessage = new FITMessage(FITGlobalMessageIds.WorkoutStep);
FITMessageField messageField;
// Repeat count
RepeatCountDuration repeatDuration = new RepeatCountDuration(placeholderStep);
repeatDuration.RepetitionCount = 3;
repeatDuration.FillFITStepMessage(serializedMessage);
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.DurationType);
Assert.IsNotNull(messageField, "Duration type field not serialized for repeat count duration");
Assert.AreEqual(FITWorkoutStepDurationTypes.RepeatCount, (FITWorkoutStepDurationTypes)messageField.GetEnum(), "Invalid duration type in field for repeat count duration");
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetValue);
Assert.IsNotNull(messageField, "Target value field not serialized for repeat count duration");
Assert.AreEqual(3, messageField.GetUInt32(), "Invalid target value in field for repeat count duration");
serializedMessage.Clear();
repeatDuration.RepetitionCount = 7;
repeatDuration.FillFITStepMessage(serializedMessage);
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.DurationType);
Assert.IsNotNull(messageField, "Duration type field not serialized for repeat count duration");
Assert.AreEqual(FITWorkoutStepDurationTypes.RepeatCount, (FITWorkoutStepDurationTypes)messageField.GetEnum(), "Invalid duration type in field for repeat count duration");
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetValue);
Assert.IsNotNull(messageField, "Target value field not serialized for repeat count duration");
Assert.AreEqual(7, messageField.GetUInt32(), "Invalid target value in field for repeat count duration");
serializedMessage.Clear();
// Repeat until calories
RepeatUntilCaloriesDuration caloriesDuration = new RepeatUntilCaloriesDuration(placeholderStep);
caloriesDuration.CaloriesToSpend = 550;
caloriesDuration.FillFITStepMessage(serializedMessage);
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.DurationType);
Assert.IsNotNull(messageField, "Duration type field not serialized for repeat until calories duration");
Assert.AreEqual(FITWorkoutStepDurationTypes.RepeatUntilCalories, (FITWorkoutStepDurationTypes)messageField.GetEnum(), "Invalid duration type in field for repeat until calories duration");
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetValue);
Assert.IsNotNull(messageField, "Target value field not serialized for repeat until calories duration");
Assert.AreEqual(550, messageField.GetUInt32(), "Invalid target value in field for repeat until calories duration");
serializedMessage.Clear();
caloriesDuration.CaloriesToSpend = 750;
caloriesDuration.FillFITStepMessage(serializedMessage);
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.DurationType);
Assert.IsNotNull(messageField, "Duration type field not serialized for repeat until calories duration");
Assert.AreEqual(FITWorkoutStepDurationTypes.RepeatUntilCalories, (FITWorkoutStepDurationTypes)messageField.GetEnum(), "Invalid duration type in field for repeat until calories duration");
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetValue);
Assert.IsNotNull(messageField, "Target value field not serialized for repeat until calories duration");
Assert.AreEqual(750, messageField.GetUInt32(), "Invalid target value in field for repeat until calories duration");
serializedMessage.Clear();
// Repeat until distance
RepeatUntilDistanceDuration distanceDuration = new RepeatUntilDistanceDuration(1, Length.Units.Kilometer, placeholderStep);
distanceDuration.FillFITStepMessage(serializedMessage);
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.DurationType);
Assert.IsNotNull(messageField, "Duration type field not serialized for repeat until distance duration");
Assert.AreEqual(FITWorkoutStepDurationTypes.RepeatUntilDistance, (FITWorkoutStepDurationTypes)messageField.GetEnum(), "Invalid duration type in field for repeat until distance duration");
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetValue);
Assert.IsNotNull(messageField, "Target value field not serialized for repeat until distance duration");
Assert.AreEqual(100000, messageField.GetUInt32(), "Invalid target value in field for repeat until distance duration");
serializedMessage.Clear();
distanceDuration = new RepeatUntilDistanceDuration(1, Length.Units.Mile, placeholderStep);
distanceDuration.FillFITStepMessage(serializedMessage);
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.DurationType);
Assert.IsNotNull(messageField, "Duration type field not serialized for repeat until distance duration");
Assert.AreEqual(FITWorkoutStepDurationTypes.RepeatUntilDistance, (FITWorkoutStepDurationTypes)messageField.GetEnum(), "Invalid duration type in field for repeat until distance duration");
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetValue);
Assert.IsNotNull(messageField, "Target value field not serialized for repeat until distance duration");
Assert.AreEqual(160934, messageField.GetUInt32(), "Invalid target value in field for repeat until distance duration");
serializedMessage.Clear();
// Repeat until HRAbove
RepeatUntilHeartRateAboveDuration hrAboveDuration = new RepeatUntilHeartRateAboveDuration(placeholderStep);
hrAboveDuration.IsPercentageMaxHeartRate = false;
hrAboveDuration.MaxHeartRate = 160;
hrAboveDuration.FillFITStepMessage(serializedMessage);
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.DurationType);
Assert.IsNotNull(messageField, "Duration type field not serialized for repeat until HRAbove duration");
Assert.AreEqual(FITWorkoutStepDurationTypes.RepeatUntilHeartRateGreaterThan, (FITWorkoutStepDurationTypes)messageField.GetEnum(), "Invalid duration type in field for repeat until HRAbove duration");
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetValue);
Assert.IsNotNull(messageField, "Target value field not serialized for repeat until HRAbove duration");
Assert.AreEqual(260, messageField.GetUInt32(), "Invalid target value in field for repeat until HRAbove duration");
serializedMessage.Clear();
hrAboveDuration.IsPercentageMaxHeartRate = true;
hrAboveDuration.MaxHeartRate = 80;
hrAboveDuration.FillFITStepMessage(serializedMessage);
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.DurationType);
Assert.IsNotNull(messageField, "Duration type field not serialized for repeat until HRAbove duration");
Assert.AreEqual(FITWorkoutStepDurationTypes.RepeatUntilHeartRateGreaterThan, (FITWorkoutStepDurationTypes)messageField.GetEnum(), "Invalid duration type in field for repeat until HRAbove duration");
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetValue);
Assert.IsNotNull(messageField, "Target value field not serialized for repeat until HRAbove duration");
Assert.AreEqual(80, messageField.GetUInt32(), "Invalid target value in field for repeat until HRAbove duration");
serializedMessage.Clear();
// Repeat until HRBelow
RepeatUntilHeartRateBelowDuration hrBelowDuration = new RepeatUntilHeartRateBelowDuration(placeholderStep);
hrBelowDuration.IsPercentageMaxHeartRate = false;
hrBelowDuration.MinHeartRate = 150;
hrBelowDuration.FillFITStepMessage(serializedMessage);
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.DurationType);
Assert.IsNotNull(messageField, "Duration type field not serialized for repeat until HRBelow duration");
Assert.AreEqual(FITWorkoutStepDurationTypes.RepeatUntilHeartRateLessThan, (FITWorkoutStepDurationTypes)messageField.GetEnum(), "Invalid duration type in field for repeat until HRBelow duration");
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetValue);
Assert.IsNotNull(messageField, "Target value field not serialized for repeat until HRBelow duration");
Assert.AreEqual(250, messageField.GetUInt32(), "Invalid target value in field for repeat until HRBelow duration");
serializedMessage.Clear();
hrBelowDuration.IsPercentageMaxHeartRate = true;
hrBelowDuration.MinHeartRate = 70;
hrBelowDuration.FillFITStepMessage(serializedMessage);
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.DurationType);
Assert.IsNotNull(messageField, "Duration type field not serialized for repeat until HRBelow duration");
Assert.AreEqual(FITWorkoutStepDurationTypes.RepeatUntilHeartRateLessThan, (FITWorkoutStepDurationTypes)messageField.GetEnum(), "Invalid duration type in field for repeat until HRBelow duration");
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetValue);
Assert.IsNotNull(messageField, "Target value field not serialized for repeat until HRBelow duration");
Assert.AreEqual(70, messageField.GetUInt32(), "Invalid target value in field for repeat until HRBelow duration");
serializedMessage.Clear();
// Repeat until PowerAbove
RepeatUntilPowerAboveDuration powerAboveDuration = new RepeatUntilPowerAboveDuration(placeholderStep);
powerAboveDuration.IsPercentFTP = false;
powerAboveDuration.MaxPower = 250;
powerAboveDuration.FillFITStepMessage(serializedMessage);
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.DurationType);
Assert.IsNotNull(messageField, "Duration type field not serialized for repeat until PowerAbove duration");
Assert.AreEqual(FITWorkoutStepDurationTypes.RepeatUntilPowerGreaterThan, (FITWorkoutStepDurationTypes)messageField.GetEnum(), "Invalid duration type in field for repeat until PowerAbove duration");
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetValue);
Assert.IsNotNull(messageField, "Target value field not serialized for repeat until PowerAbove duration");
Assert.AreEqual(1250, messageField.GetUInt32(), "Invalid target value in field for repeat until PowerAbove duration");
serializedMessage.Clear();
powerAboveDuration.IsPercentFTP = true;
powerAboveDuration.MaxPower = 100;
powerAboveDuration.FillFITStepMessage(serializedMessage);
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.DurationType);
Assert.IsNotNull(messageField, "Duration type field not serialized for repeat until PowerAbove duration");
Assert.AreEqual(FITWorkoutStepDurationTypes.RepeatUntilPowerGreaterThan, (FITWorkoutStepDurationTypes)messageField.GetEnum(), "Invalid duration type in field for repeat until PowerAbove duration");
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetValue);
Assert.IsNotNull(messageField, "Target value field not serialized for repeat until PowerAbove duration");
Assert.AreEqual(100, messageField.GetUInt32(), "Invalid target value in field for repeat until PowerAbove duration");
serializedMessage.Clear();
// Repeat until HRBelow
RepeatUntilPowerBelowDuration powerBelowDuration = new RepeatUntilPowerBelowDuration(placeholderStep);
powerBelowDuration.IsPercentFTP = false;
powerBelowDuration.MinPower = 150;
powerBelowDuration.FillFITStepMessage(serializedMessage);
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.DurationType);
Assert.IsNotNull(messageField, "Duration type field not serialized for repeat until PowerBelow duration");
Assert.AreEqual(FITWorkoutStepDurationTypes.RepeatUntilPowerLessThan, (FITWorkoutStepDurationTypes)messageField.GetEnum(), "Invalid duration type in field for repeat until PowerBelow duration");
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetValue);
Assert.IsNotNull(messageField, "Target value field not serialized for repeat until PowerBelow duration");
Assert.AreEqual(1150, messageField.GetUInt32(), "Invalid target value in field for repeat until PowerBelow duration");
serializedMessage.Clear();
powerBelowDuration.IsPercentFTP = true;
powerBelowDuration.MinPower = 270;
powerBelowDuration.FillFITStepMessage(serializedMessage);
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.DurationType);
Assert.IsNotNull(messageField, "Duration type field not serialized for repeat until PowerBelow duration");
Assert.AreEqual(FITWorkoutStepDurationTypes.RepeatUntilPowerLessThan, (FITWorkoutStepDurationTypes)messageField.GetEnum(), "Invalid duration type in field for repeat until PowerBelow duration");
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetValue);
Assert.IsNotNull(messageField, "Target value field not serialized for repeat until PowerBelow duration");
Assert.AreEqual(270, messageField.GetUInt32(), "Invalid target value in field for repeat until PowerBelow duration");
serializedMessage.Clear();
// Repeat until time
RepeatUntilTimeDuration timeDuration = new RepeatUntilTimeDuration(placeholderStep);
timeDuration.TimeInSeconds = 600;
timeDuration.FillFITStepMessage(serializedMessage);
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.DurationType);
Assert.IsNotNull(messageField, "Duration type field not serialized for repeat until time duration");
Assert.AreEqual(FITWorkoutStepDurationTypes.RepeatUntilTime, (FITWorkoutStepDurationTypes)messageField.GetEnum(), "Invalid duration type in field for repeat until time duration");
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetValue);
Assert.IsNotNull(messageField, "Target value field not serialized for repeat until time duration");
Assert.AreEqual(600000, messageField.GetUInt32(), "Invalid target value in field for repeat until time duration");
serializedMessage.Clear();
timeDuration.TimeInSeconds = 350;
timeDuration.FillFITStepMessage(serializedMessage);
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.DurationType);
Assert.IsNotNull(messageField, "Duration type field not serialized for repeat until time duration");
Assert.AreEqual(FITWorkoutStepDurationTypes.RepeatUntilTime, (FITWorkoutStepDurationTypes)messageField.GetEnum(), "Invalid duration type in field for repeat until time duration");
messageField = serializedMessage.GetField((Byte)FITWorkoutStepFieldIds.TargetValue);
Assert.IsNotNull(messageField, "Target value field not serialized for repeat until time duration");
Assert.AreEqual(350000, messageField.GetUInt32(), "Invalid target value in field for repeat until time duration");
serializedMessage.Clear();
}
public RepeatUntilHeartRateAboveDuration(Stream stream, DataVersion version, RepeatStep parent)
: this(parent)
{
Deserialize(stream, version);
}
public void TestFITDeserialization()
{
Workout placeholderWorkout = new Workout("Test", PluginMain.GetApplication().Logbook.ActivityCategories[0]);
RepeatStep placeholderStep = new RepeatStep(placeholderWorkout);
FITMessage serializedMessage = new FITMessage(FITGlobalMessageIds.WorkoutStep);
FITMessageField typeField = new FITMessageField((Byte)FITWorkoutStepFieldIds.DurationType);
FITMessageField valueField = new FITMessageField((Byte)FITWorkoutStepFieldIds.TargetValue);
IRepeatDuration deserializedDuration;
serializedMessage.AddField(typeField);
serializedMessage.AddField(valueField);
// Repeat count
typeField.SetEnum((Byte)FITWorkoutStepDurationTypes.RepeatCount);
valueField.SetUInt32(6);
deserializedDuration = DurationFactory.Create(serializedMessage, placeholderStep);
Assert.IsTrue(deserializedDuration is RepeatCountDuration, "Repeat count duration not properly FIT deserialized");
RepeatCountDuration repeatDuration = deserializedDuration as RepeatCountDuration;
Assert.AreEqual(6, repeatDuration.RepetitionCount, "Invalid value deserialized for FIT repeat count duration");
valueField.SetUInt32(2);
deserializedDuration = DurationFactory.Create(serializedMessage, placeholderStep);
Assert.IsTrue(deserializedDuration is RepeatCountDuration, "Repeat count duration not properly FIT deserialized");
repeatDuration = deserializedDuration as RepeatCountDuration;
Assert.AreEqual(2, repeatDuration.RepetitionCount, "Invalid value deserialized for FIT repeat count duration");
// Repeat until calories
typeField.SetEnum((Byte)FITWorkoutStepDurationTypes.RepeatUntilCalories);
valueField.SetUInt32(666);
deserializedDuration = DurationFactory.Create(serializedMessage, placeholderStep);
Assert.IsTrue(deserializedDuration is RepeatUntilCaloriesDuration, "Repeat until calories duration not properly FIT deserialized");
RepeatUntilCaloriesDuration caloriesDuration = deserializedDuration as RepeatUntilCaloriesDuration;
Assert.AreEqual(666, caloriesDuration.CaloriesToSpend, "Invalid value deserialized for FIT repeat until calories duration");
valueField.SetUInt32(150);
deserializedDuration = DurationFactory.Create(serializedMessage, placeholderStep);
Assert.IsTrue(deserializedDuration is RepeatUntilCaloriesDuration, "Repeat until calories duration not properly FIT deserialized");
caloriesDuration = deserializedDuration as RepeatUntilCaloriesDuration;
Assert.AreEqual(150, caloriesDuration.CaloriesToSpend, "Invalid value deserialized for FIT repeat until calories duration");
// Repeat until distance
typeField.SetEnum((Byte)FITWorkoutStepDurationTypes.RepeatUntilDistance);
valueField.SetUInt32(100000);
deserializedDuration = DurationFactory.Create(serializedMessage, placeholderStep);
Assert.IsTrue(deserializedDuration is RepeatUntilDistanceDuration, "Repeat until distance duration not properly FIT deserialized");
RepeatUntilDistanceDuration distanceDuration = deserializedDuration as RepeatUntilDistanceDuration;
Assert.AreEqual(1,
Length.Convert(distanceDuration.GetDistanceInBaseUnit(), distanceDuration.BaseUnit, Length.Units.Kilometer),
STCommon.Data.Constants.Delta,
"Invalid value deserialized for FIT repeat until distance duration");
valueField.SetUInt32(160934);
deserializedDuration = DurationFactory.Create(serializedMessage, placeholderStep);
Assert.IsTrue(deserializedDuration is RepeatUntilDistanceDuration, "Repeat until distance duration not properly FIT deserialized");
distanceDuration = deserializedDuration as RepeatUntilDistanceDuration;
Assert.AreEqual(1,
Length.Convert(distanceDuration.GetDistanceInBaseUnit(), distanceDuration.BaseUnit, Length.Units.Mile),
STCommon.Data.Constants.Delta,
"Invalid value deserialized for FIT repeat until distance duration");
// Repeat until HR Above
typeField.SetEnum((Byte)FITWorkoutStepDurationTypes.RepeatUntilHeartRateGreaterThan);
valueField.SetUInt32(220);
deserializedDuration = DurationFactory.Create(serializedMessage, placeholderStep);
Assert.IsTrue(deserializedDuration is RepeatUntilHeartRateAboveDuration, "Repeat until HRAbove duration not properly FIT deserialized");
RepeatUntilHeartRateAboveDuration hrAboveDuration = deserializedDuration as RepeatUntilHeartRateAboveDuration;
Assert.IsFalse(hrAboveDuration.IsPercentageMaxHeartRate, "Invalid value deserialized for FIT repeat until HRAbove duration");
Assert.AreEqual(120, hrAboveDuration.MaxHeartRate, "Invalid value deserialized for FIT repeat until HRAbove duration");
valueField.SetUInt32(80);
deserializedDuration = DurationFactory.Create(serializedMessage, placeholderStep);
Assert.IsTrue(deserializedDuration is RepeatUntilHeartRateAboveDuration, "Repeat until HRAbove duration not properly FIT deserialized");
hrAboveDuration = deserializedDuration as RepeatUntilHeartRateAboveDuration;
Assert.IsTrue(hrAboveDuration.IsPercentageMaxHeartRate, "Invalid value deserialized for FIT repeat until HRAbove duration");
Assert.AreEqual(80, hrAboveDuration.MaxHeartRate, "Invalid value deserialized for FIT repeat until HRAbove duration");
// Repeat until HR Below
typeField.SetEnum((Byte)FITWorkoutStepDurationTypes.RepeatUntilHeartRateLessThan);
valueField.SetUInt32(230);
deserializedDuration = DurationFactory.Create(serializedMessage, placeholderStep);
Assert.IsTrue(deserializedDuration is RepeatUntilHeartRateBelowDuration, "Repeat until HRBelow duration not properly FIT deserialized");
RepeatUntilHeartRateBelowDuration hrBelowDuration = deserializedDuration as RepeatUntilHeartRateBelowDuration;
Assert.IsFalse(hrBelowDuration.IsPercentageMaxHeartRate, "Invalid value deserialized for FIT repeat until HRBelow duration");
Assert.AreEqual(130, hrBelowDuration.MinHeartRate, "Invalid value deserialized for FIT repeat until HRBelow duration");
valueField.SetUInt32(65);
deserializedDuration = DurationFactory.Create(serializedMessage, placeholderStep);
Assert.IsTrue(deserializedDuration is RepeatUntilHeartRateBelowDuration, "Repeat until HRBelow duration not properly FIT deserialized");
hrBelowDuration = deserializedDuration as RepeatUntilHeartRateBelowDuration;
Assert.IsTrue(hrBelowDuration.IsPercentageMaxHeartRate, "Invalid value deserialized for FIT repeat until HRBelow duration");
Assert.AreEqual(65, hrBelowDuration.MinHeartRate, "Invalid value deserialized for FIT repeat until HRBelow duration");
// Repeat until Power Above
typeField.SetEnum((Byte)FITWorkoutStepDurationTypes.RepeatUntilPowerGreaterThan);
valueField.SetUInt32(1220);
deserializedDuration = DurationFactory.Create(serializedMessage, placeholderStep);
Assert.IsTrue(deserializedDuration is RepeatUntilPowerAboveDuration, "Repeat until PowerAbove duration not properly FIT deserialized");
RepeatUntilPowerAboveDuration powerAboveDuration = deserializedDuration as RepeatUntilPowerAboveDuration;
Assert.IsFalse(powerAboveDuration.IsPercentFTP, "Invalid value deserialized for FIT repeat until PowerAbove duration");
Assert.AreEqual(220, powerAboveDuration.MaxPower, "Invalid value deserialized for FIT repeat until PowerAbove duration");
valueField.SetUInt32(80);
deserializedDuration = DurationFactory.Create(serializedMessage, placeholderStep);
Assert.IsTrue(deserializedDuration is RepeatUntilPowerAboveDuration, "Repeat until PowerAbove duration not properly FIT deserialized");
powerAboveDuration = deserializedDuration as RepeatUntilPowerAboveDuration;
Assert.IsTrue(powerAboveDuration.IsPercentFTP, "Invalid value deserialized for FIT repeat until PowerAbove duration");
Assert.AreEqual(80, powerAboveDuration.MaxPower, "Invalid value deserialized for FIT repeat until PowerAbove duration");
// Repeat until Power Below
typeField.SetEnum((Byte)FITWorkoutStepDurationTypes.RepeatUntilPowerLessThan);
valueField.SetUInt32(1400);
deserializedDuration = DurationFactory.Create(serializedMessage, placeholderStep);
Assert.IsTrue(deserializedDuration is RepeatUntilPowerBelowDuration, "Repeat until PowerBelow duration not properly FIT deserialized");
RepeatUntilPowerBelowDuration powerBelowDuration = deserializedDuration as RepeatUntilPowerBelowDuration;
Assert.IsFalse(powerBelowDuration.IsPercentFTP, "Invalid value deserialized for FIT repeat until PowerBelow duration");
Assert.AreEqual(400, powerBelowDuration.MinPower, "Invalid value deserialized for FIT repeat until PowerBelow duration");
valueField.SetUInt32(125);
deserializedDuration = DurationFactory.Create(serializedMessage, placeholderStep);
Assert.IsTrue(deserializedDuration is RepeatUntilPowerBelowDuration, "Repeat until PowerBelow duration not properly FIT deserialized");
powerBelowDuration = deserializedDuration as RepeatUntilPowerBelowDuration;
Assert.IsTrue(powerBelowDuration.IsPercentFTP, "Invalid value deserialized for FIT repeat until PowerBelow duration");
Assert.AreEqual(125, powerBelowDuration.MinPower, "Invalid value deserialized for FIT repeat until PowerBelow duration");
// Repeat until time
typeField.SetEnum((Byte)FITWorkoutStepDurationTypes.RepeatUntilTime);
valueField.SetUInt32(60000);
deserializedDuration = DurationFactory.Create(serializedMessage, placeholderStep);
Assert.IsTrue(deserializedDuration is RepeatUntilTimeDuration, "Repeat until time duration not properly FIT deserialized");
RepeatUntilTimeDuration timeDuration = deserializedDuration as RepeatUntilTimeDuration;
Assert.AreEqual(60, timeDuration.TimeInSeconds, "Invalid value deserialized for FIT repeat until time duration");
valueField.SetUInt32(600000);
deserializedDuration = DurationFactory.Create(serializedMessage, placeholderStep);
Assert.IsTrue(deserializedDuration is RepeatUntilTimeDuration, "Repeat until time duration not properly FIT deserialized");
timeDuration = deserializedDuration as RepeatUntilTimeDuration;
Assert.AreEqual(600, timeDuration.TimeInSeconds, "Invalid value deserialized for FIT repeat until time duration");
}
private void RegisterRepeatStep(RepeatStep stepToRegister)
{
foreach (IStep step in stepToRegister.StepsToRepeat)
{
RegisterStep(step);
}
}
public void TestTCXDeserialization()
{
XmlDocument testDocument = new XmlDocument();
XmlNode readNode;
XmlNode database;
Workout placeholderWorkout = new Workout("Test", PluginMain.GetApplication().Logbook.ActivityCategories[0]);
RepeatStep placeholderStep = new RepeatStep(placeholderWorkout);
// Setup document
testDocument.AppendChild(testDocument.CreateXmlDeclaration("1.0", "UTF-8", "no"));
database = testDocument.CreateNode(XmlNodeType.Element, "TrainingCenterDatabase", null);
testDocument.AppendChild(database);
XmlAttribute attribute = testDocument.CreateAttribute("xmlns", "xsi", GarminFitnessPlugin.Constants.xmlns);
attribute.Value = "http://www.w3.org/2001/XMLSchema-instance";
database.Attributes.Append(attribute);
readNode = testDocument.CreateElement("TestNode");
database.AppendChild(readNode);
// Repeat count
readNode.InnerXml = repeatCountDurationResult1;
RepeatCountDuration countDuration = new RepeatCountDuration(placeholderStep);
countDuration.Deserialize(readNode.FirstChild);
Assert.AreEqual(4, countDuration.RepetitionCount, "Invalid number of repetitions deserialized");
readNode.InnerXml = repeatCountDurationResult2;
countDuration = new RepeatCountDuration(placeholderStep);
countDuration.Deserialize(readNode.FirstChild);
Assert.AreEqual(10, countDuration.RepetitionCount, "Invalid number of repetitions deserialized");
// All other repeat durtions should not deserialize from TCX
try
{
RepeatUntilCaloriesDuration caloriesDuration = new RepeatUntilCaloriesDuration(placeholderStep);
caloriesDuration.Deserialize(readNode.FirstChild);
Assert.Fail("Repeat until calories should not deserialize");
}
catch (NotSupportedException)
{
}
try
{
RepeatUntilDistanceDuration distanceDuration = new RepeatUntilDistanceDuration(placeholderStep);
distanceDuration.Deserialize(readNode.FirstChild);
Assert.Fail("Repeat until distance should not deserialize");
}
catch (NotSupportedException)
{
}
try
{
RepeatUntilHeartRateAboveDuration hrAboveDuration = new RepeatUntilHeartRateAboveDuration(placeholderStep);
hrAboveDuration.Deserialize(readNode.FirstChild);
Assert.Fail("Repeat until HRAbove should not deserialize");
}
catch (NotSupportedException)
{
}
try
{
RepeatUntilHeartRateBelowDuration hrBelowDuration = new RepeatUntilHeartRateBelowDuration(placeholderStep);
hrBelowDuration.Deserialize(readNode.FirstChild);
Assert.Fail("Repeat until HRBelow should not deserialize");
}
catch (NotSupportedException)
{
}
try
{
RepeatUntilPowerAboveDuration powerAboveDuration = new RepeatUntilPowerAboveDuration(placeholderStep);
powerAboveDuration.Deserialize(readNode.FirstChild);
Assert.Fail("Repeat until PowerAbove should not deserialize");
}
catch (NotSupportedException)
{
}
try
{
RepeatUntilPowerBelowDuration powerBelowDuration = new RepeatUntilPowerBelowDuration(placeholderStep);
powerBelowDuration.Deserialize(readNode.FirstChild);
Assert.Fail("Repeat until PowerBelow should not deserialize");
}
catch (NotSupportedException)
{
}
try
{
RepeatUntilTimeDuration timeDuration = new RepeatUntilTimeDuration(placeholderStep);
timeDuration.Deserialize(readNode.FirstChild);
Assert.Fail("Repeat until time should not deserialize");
}
catch (NotSupportedException)
{
}
try
{
RepeatUntilCaloriesDuration caloriesDuration = new RepeatUntilCaloriesDuration(placeholderStep);
caloriesDuration.Deserialize(readNode.FirstChild);
Assert.Fail("Repeat until calories should not deserialize");
}
catch (NotSupportedException)
{
}
}