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); } }