public void ensureFromModelViewCreatesContinuousDimensionIntervalWithExpectedData()
{
double minValue = 20;
double maxValue = 120;
double increment = 5;
string unit = "m";
AddContinuousDimensionIntervalModelView continuousDimensionIntervalModelView = new AddContinuousDimensionIntervalModelView()
{
minValue = minValue,
maxValue = maxValue,
increment = increment,
unit = unit
};
ContinuousDimensionInterval continuousDimensionInterval = (ContinuousDimensionInterval)DimensionModelViewService.fromModelView(continuousDimensionIntervalModelView);
double expectedMinValue = MeasurementUnitService.convertFromUnit(minValue, unit);
double expectedMaxvalue = MeasurementUnitService.convertFromUnit(maxValue, unit);
double expectedIncrement = MeasurementUnitService.convertFromUnit(increment, unit);
Assert.Equal(expectedMinValue, continuousDimensionInterval.minValue);
Assert.Equal(expectedMaxvalue, continuousDimensionInterval.maxValue);
Assert.Equal(expectedIncrement, continuousDimensionInterval.increment);
}
public void ensureFromModelViewCreatesInstance()
{
double minWidth = 25;
double maxWidth = 50;
double recommendedWidth = 35;
string unit = "cm";
AddProductSlotWidthsModelView productSlotWidthsModelView = new AddProductSlotWidthsModelView();
productSlotWidthsModelView.minWidth = minWidth;
productSlotWidthsModelView.maxWidth = maxWidth;
productSlotWidthsModelView.recommendedWidth = recommendedWidth;
productSlotWidthsModelView.unit = unit;
ProductSlotWidths slotWidths = ProductSlotWidthsModelViewService.fromModelView(productSlotWidthsModelView);
double expectedMinWidth = MeasurementUnitService.convertFromUnit(minWidth, unit);
double expectedMaxWidth = MeasurementUnitService.convertFromUnit(maxWidth, unit);
double expectedRecommendedWidth = MeasurementUnitService.convertFromUnit(recommendedWidth, unit);
Assert.Equal(expectedMinWidth, slotWidths.minWidth);
Assert.Equal(expectedMaxWidth, slotWidths.maxWidth);
Assert.Equal(expectedRecommendedWidth, slotWidths.recommendedWidth);
}
public void ensureConvertFromUnitUsesMinimumUnitIfArgumentIsNull()
{
Console.WriteLine("ensureConvertFromUnitUsesMinimumUnitIfArgumentIsNull");
double value = 100;
Assert.Equal(100, MeasurementUnitService.convertFromUnit(value, null), 1);
}
public void ensureConvertFromUnitThrowsArgumentException()
{
Console.WriteLine("ensureConvertToUnitThrowsArgumentException");
double value = 1;
Action action = () => MeasurementUnitService.convertFromUnit(value, "der alte würfelt nicht");
Assert.Throws <ArgumentException>(action);
}
public void ensureConvertFromUnitSucceeds()
{
Console.WriteLine("ensureConvertFromUnitSucceds");
double value = 100;
string unit = "dm";
Assert.Equal(10000, MeasurementUnitService.convertFromUnit(value, unit), 1);
}
/// <summary>
/// Converts the value from a unit to another unit.
/// </summary>
/// <param name="convertUnitMV">ConvertUnitModelView containing unit conversion data.</param>
/// <returns>ConvertUnitModelView with converted value.</returns>
public ConvertUnitModelView convertValue(ConvertUnitModelView convertUnitMV)
{
double valueInMM = MeasurementUnitService.convertFromUnit(convertUnitMV.value, convertUnitMV.fromUnit);
double newValue = MeasurementUnitService.convertToUnit(valueInMM, convertUnitMV.toUnit);
convertUnitMV.value = newValue;
return(convertUnitMV);
}
/// <summary>
/// Builds a SingleValueDimension instance from a SingleValueDimensionDTO
/// </summary>
/// <returns>SingleValueDimension instance</returns>
public override Dimension toEntity()
{
double value = MeasurementUnitService.convertFromUnit(this.value, unit);
SingleValueDimension instanceFromDTO = new SingleValueDimension(value);
instanceFromDTO.Id = id;
return(instanceFromDTO);
}
/// <summary>
/// Builds a ContinuousDimensionInterval instance from a ContinuousDimensionIntervalDTO
/// </summary>
/// <returns>ContinuousDimensionInterval instance</returns>
public override Dimension toEntity()
{
double minValue = MeasurementUnitService.convertFromUnit(this.minValue, unit);
double maxValue = MeasurementUnitService.convertFromUnit(this.maxValue, unit);
double increment = MeasurementUnitService.convertFromUnit(this.increment, unit);
ContinuousDimensionInterval instanceFromDTO = new ContinuousDimensionInterval(minValue, maxValue, increment);
instanceFromDTO.Id = id;
return(instanceFromDTO);
}
/// <summary>
/// Converts an instance of AddCustomizedDimensionsModelView into an instance of CustomizedDimensions.
/// </summary>
/// <param name="modelView">Instance of AddCustomizedDimensionsModelView.</param>
/// <returns>The created instance of CustomizedDimensions</returns>
/// <exception cref="System.ArgumentException">Thrown when the provided AddCustomizedDimensionsModelView is null.</exception>
public static CustomizedDimensions fromModelView(AddCustomizedDimensionsModelView modelView)
{
if (modelView == null)
{
throw new ArgumentException(ERROR_NULL_MODEL_VIEW);
}
double height = MeasurementUnitService.convertFromUnit(modelView.height, modelView.unit);
double width = MeasurementUnitService.convertFromUnit(modelView.width, modelView.unit);
double depth = MeasurementUnitService.convertFromUnit(modelView.depth, modelView.unit);
return(CustomizedDimensions.valueOf(height, width, depth));
}
private bool modelViewEqualsDimension(AddDimensionModelView modelView, Dimension dimension)
{
if (modelView.GetType() == typeof(AddDiscreteDimensionIntervalModelView) && dimension.GetType() == typeof(DiscreteDimensionInterval))
{
DiscreteDimensionInterval discreteDimension = (DiscreteDimensionInterval)dimension;
AddDiscreteDimensionIntervalModelView discreteModelView = (AddDiscreteDimensionIntervalModelView)modelView;
List <double> expectedValues = new List <double>();
foreach (double modelViewValue in discreteModelView.values)
{
double expectedValue = MeasurementUnitService.convertFromUnit(modelViewValue, discreteModelView.unit);
expectedValues.Add(expectedValue);
}
var firstNotSecond = expectedValues.Except(discreteDimension.values.Select(dv => dv.value)).ToList();
var secondNotFirst = discreteDimension.values.Select(dv => dv.value).Except(expectedValues).ToList();
bool equalLists = !firstNotSecond.Any() && !secondNotFirst.Any();
return(equalLists);
}
else if (modelView.GetType() == typeof(AddSingleValueDimensionModelView) && dimension.GetType() == typeof(SingleValueDimension))
{
SingleValueDimension singleValueDimension = (SingleValueDimension)dimension;
AddSingleValueDimensionModelView singleValueModelView = (AddSingleValueDimensionModelView)modelView;
double expectedValue = MeasurementUnitService.convertFromUnit(singleValueModelView.value, singleValueModelView.unit);
return(expectedValue.Equals(singleValueDimension.value));
}
else if (modelView.GetType() == typeof(AddContinuousDimensionIntervalModelView) && dimension.GetType() == typeof(ContinuousDimensionInterval))
{
ContinuousDimensionInterval continuousDimension = (ContinuousDimensionInterval)dimension;
AddContinuousDimensionIntervalModelView continuousModelView = (AddContinuousDimensionIntervalModelView)modelView;
double expectedMinValue = MeasurementUnitService.convertFromUnit(continuousModelView.minValue, continuousModelView.unit);
double expectedMaxValue = MeasurementUnitService.convertFromUnit(continuousModelView.maxValue, continuousModelView.unit);
double expectedIncrement = MeasurementUnitService.convertFromUnit(continuousModelView.increment, continuousModelView.unit);
return(expectedMinValue.Equals(continuousDimension.minValue) &&
expectedMaxValue.Equals(continuousDimension.maxValue) &&
expectedIncrement.Equals(continuousDimension.increment));
}
else
{
return(false);
}
}
public CustomizedDimensions toEntity()
{
if (unit == null)
{
CustomizedDimensions custDimensions = CustomizedDimensions.valueOf(height, width, depth);
custDimensions.Id = this.Id;
return(custDimensions);
}
else
{
return(CustomizedDimensions.valueOf(MeasurementUnitService.convertFromUnit(this.height, unit)
, MeasurementUnitService.convertFromUnit(this.width, unit)
, MeasurementUnitService.convertFromUnit(this.depth, unit)));
}
}
/// <summary>
/// Converts an instance of AddProductSlotWidthsModelView into an instance of ProductSlotWidths.
/// </summary>
/// <param name="modelView">Instance of AddProductSlotWidthsModelView.</param>
/// <returns>The created instance of ProductSlotWidths.</returns>
/// <exception cref="System.ArgumentNullException">Thrown when the provided instance of AddProductSlotWidthsModelView is null.</exception>
public static ProductSlotWidths fromModelView(AddProductSlotWidthsModelView modelView)
{
if (modelView == null)
{
throw new ArgumentNullException(ERROR_NULL_MODEL_VIEW);
}
double minWidth = MeasurementUnitService.convertFromUnit(modelView.minWidth, modelView.unit);
double maxWidth = MeasurementUnitService.convertFromUnit(modelView.maxWidth, modelView.unit);
double recommendedWidth = MeasurementUnitService.convertFromUnit(modelView.recommendedWidth, modelView.unit);
return(ProductSlotWidths.valueOf(minWidth, maxWidth, recommendedWidth));
}
/// <summary>
/// Builds a DiscreteDimensionInterval instance from a DiscreteDimensionIntervalDTO
/// </summary>
/// <returns>DiscreteDimensionInterval instance</returns>
public override Dimension toEntity()
{
List <double> valuesInMilimetres = new List <double>();
foreach (double value in values)
{
valuesInMilimetres.Add(MeasurementUnitService.convertFromUnit(value, unit));
}
DiscreteDimensionInterval instanceFromDTO = new DiscreteDimensionInterval(valuesInMilimetres);
instanceFromDTO.Id = id;
return(instanceFromDTO);
}
/// <summary>
/// Creates an instance of Dimension from an AddDimensionModelView instance.
/// </summary>
/// <param name="addDimensionModelView">AddDimensionModelView instance.</param>
/// <returns>Created Dimension.</returns>
/// <exception cref="System.ArgumentNullException">Thrown when the provided AddDimensionModelView is null.</exception>
public static Dimension fromModelView(AddDimensionModelView addDimensionModelView)
{
if (addDimensionModelView == null)
{
throw new ArgumentNullException(ERROR_NULL_DIMENSION_VIEW);
}
string unit = addDimensionModelView.unit;
Type modelViewType = addDimensionModelView.GetType();
if (modelViewType == typeof(AddSingleValueDimensionModelView))
{
AddSingleValueDimensionModelView singleValueMV = (AddSingleValueDimensionModelView)addDimensionModelView;
double dimensionValue = MeasurementUnitService.convertFromUnit(singleValueMV.value, unit);
return(new SingleValueDimension(dimensionValue));
}
else if (modelViewType == typeof(AddDiscreteDimensionIntervalModelView))
{
AddDiscreteDimensionIntervalModelView discreteMV = (AddDiscreteDimensionIntervalModelView)addDimensionModelView;
List <double> dimensionValues = new List <double>();
foreach (double value in discreteMV.values)
{
double dimensionValue = MeasurementUnitService.convertFromUnit(value, unit);
dimensionValues.Add(dimensionValue);
}
return(new DiscreteDimensionInterval(dimensionValues));
}
else if (modelViewType == typeof(AddContinuousDimensionIntervalModelView))
{
AddContinuousDimensionIntervalModelView continuousMV = (AddContinuousDimensionIntervalModelView)addDimensionModelView;
double minValue = MeasurementUnitService.convertFromUnit(continuousMV.minValue, unit);
double maxValue = MeasurementUnitService.convertFromUnit(continuousMV.maxValue, unit);
double increment = MeasurementUnitService.convertFromUnit(continuousMV.increment, unit);
return(new ContinuousDimensionInterval(minValue, maxValue, increment));
}
else
{
throw new NotImplementedException(ERROR_NO_IMPLEMENTATION_UNKNOWN_VIEW);
}
}
public void ensureFromModelViewCreatesSingleValueDimensionWithExpectedData()
{
double value = 25;
string unit = "dm";
AddSingleValueDimensionModelView singleValueDimensionModelView = new AddSingleValueDimensionModelView();
singleValueDimensionModelView.value = value;
singleValueDimensionModelView.unit = unit;
SingleValueDimension singleValueDimension = (SingleValueDimension)DimensionModelViewService.fromModelView(singleValueDimensionModelView);
double expectedValue = MeasurementUnitService.convertFromUnit(value, unit);
Assert.Equal(expectedValue, singleValueDimension.value);
}
public void ensureFromModelViewCreatesDiscreteDimensionIntervalWithExpectedData()
{
List <double> values = new List <double>()
{
12, 31, 45, 67
};
string unit = "cm";
AddDiscreteDimensionIntervalModelView discreteDimensionIntervalModelView = new AddDiscreteDimensionIntervalModelView();
discreteDimensionIntervalModelView.values = values;
discreteDimensionIntervalModelView.unit = unit;
DiscreteDimensionInterval discreteDimensionInterval = (DiscreteDimensionInterval)DimensionModelViewService.fromModelView(discreteDimensionIntervalModelView);
for (int i = 0; i < values.Count; i++)
{
double expectedValue = MeasurementUnitService.convertFromUnit(values[i], unit);
Assert.Equal(expectedValue, discreteDimensionInterval.values[i].value);
}
}
