public void ensureFromCollectionWithUnitThrowsExceptionIfElementIsNull()
{
double minValue = 20;
double maxValue = 60;
double increment = 2;
Dimension continuousDimensionInterval = new ContinuousDimensionInterval(minValue, maxValue, increment);
List <double> values = new List <double>()
{
21, 35, 42
};
Dimension discreteDimensionInterval = new DiscreteDimensionInterval(values);
Dimension nullDimension = null;
IEnumerable <Dimension> dimensions = new List <Dimension>()
{
continuousDimensionInterval, discreteDimensionInterval, nullDimension
};
string unit = "m";
Action fromCollection = () => DimensionModelViewService.fromCollection(dimensions, unit);
Assert.Throws <ArgumentNullException>(fromCollection);
}
/// <summary>
/// Converts an instance of Measurement into an instance of GetMeasurementModelView
/// with the values converted to the specified unit.
/// </summary>
/// <param name="measurement">Measurement being converted.</param>
/// <param name="unit">Unit to which the values will be converted.</param>
/// <returns>An instance of GetMeasurementModelView with the Measurement data.</returns>
/// <exception cref="System.ArgumentNullException">If the provided Measurement is null.</exception>
public static GetMeasurementModelView fromEntity(Measurement measurement, string unit)
{
if (measurement == null)
{
throw new ArgumentNullException(ERROR_NULL_MEASUREMENT);
}
//if no unit is provided, resort to the default implementation
if (Strings.isNullOrEmpty(unit))
{
return(fromEntity(measurement));
}
GetDimensionModelView heightMV = DimensionModelViewService.fromEntity(measurement.height, unit);
GetDimensionModelView widthMV = DimensionModelViewService.fromEntity(measurement.width, unit);
GetDimensionModelView depthMV = DimensionModelViewService.fromEntity(measurement.depth, unit);
GetMeasurementModelView measurementModelView = new GetMeasurementModelView();
measurementModelView.measurementId = measurement.Id;
measurementModelView.height = heightMV;
measurementModelView.width = widthMV;
measurementModelView.depth = depthMV;
return(measurementModelView);
}
public void ensureFromEntityWithUnitConvertsDiscreteDimensionInterval()
{
List <double> values = new List <double>()
{
21, 35, 42
};
Dimension discreteDimensionInterval = new DiscreteDimensionInterval(values);
string unit = "dm";
GetDimensionModelView getDimensionModelView = DimensionModelViewService.fromEntity(discreteDimensionInterval, unit);
GetDiscreteDimensionIntervalModelView result = (GetDiscreteDimensionIntervalModelView)getDimensionModelView;
GetDiscreteDimensionIntervalModelView expected = new GetDiscreteDimensionIntervalModelView();
List <double> expectedValues = new List <double>();
foreach (double dimensionValue in values)
{
double convertedValue = MeasurementUnitService.convertToUnit(dimensionValue, unit);
expectedValues.Add(convertedValue);
}
expected.values = expectedValues;
expected.unit = unit;
Assert.Equal(expected.values, result.values);
Assert.Equal(expected.unit, result.unit);
}
public void ensureFromEntityWithUnitConvertsContinuousDimensionInterval()
{
double minValue = 20;
double maxValue = 60;
double increment = 2;
Dimension continuousDimensionInterval = new ContinuousDimensionInterval(minValue, maxValue, increment);
string unit = "dm";
GetDimensionModelView getDimensionModelView = DimensionModelViewService.fromEntity(continuousDimensionInterval, unit);
GetContinuousDimensionIntervalModelView result = (GetContinuousDimensionIntervalModelView)getDimensionModelView;
GetContinuousDimensionIntervalModelView expected = new GetContinuousDimensionIntervalModelView();
expected.minValue = MeasurementUnitService.convertToUnit(minValue, unit);
expected.maxValue = MeasurementUnitService.convertToUnit(maxValue, unit);
expected.increment = MeasurementUnitService.convertToUnit(increment, unit);
expected.unit = unit;
Assert.Equal(expected.minValue, result.minValue);
Assert.Equal(expected.maxValue, result.maxValue);
Assert.Equal(expected.increment, result.increment);
Assert.Equal(expected.unit, result.unit);
}
public void ensureFromCollectionThrowsExceptionIfEnumerableIsNull()
{
IEnumerable <Dimension> dimensions = null;
Action fromCollection = () => DimensionModelViewService.fromCollection(dimensions);
Assert.Throws <ArgumentNullException>(fromCollection);
}
public void ensureFromModelViewsThrowsExceptionIfEnumerableIsNull()
{
IEnumerable <AddDimensionModelView> dimensionModelViews = null;
Action fromModelViews = () => DimensionModelViewService.fromModelViews(dimensionModelViews);
Assert.Throws <ArgumentNullException>(fromModelViews);
}
public void ensureFromEntityThrowsExceptionIfDimensionIsNull()
{
Dimension dimension = null;
Action fromEntity = () => DimensionModelViewService.fromEntity(dimension);
Assert.Throws <ArgumentNullException>(fromEntity);
}
public void ensureFromEntityWithUnitThrowsExceptionIfDimensionIsNull()
{
Dimension dimension = null;
string unit = "dm";
Action fromEntity = () => DimensionModelViewService.fromEntity(dimension, unit);
Assert.Throws <ArgumentNullException>(fromEntity);
}
public void ensureFromEntityConvertsToGetSingleValueDimensionModelViewIfProvidedDimensionIsSingleValue()
{
Dimension singleValueDimension = new SingleValueDimension(15);
GetDimensionModelView getDimensionModelView = DimensionModelViewService.fromEntity(singleValueDimension);
Type expectedDimensionType = typeof(GetSingleValueDimensionModelView);
Assert.Equal(expectedDimensionType, getDimensionModelView.GetType());
}
public void ensureFromCollectionWithEmptyUnitUsesMinimumUnit()
{
double minValue = 20;
double maxValue = 60;
double increment = 2;
Dimension continuousDimensionInterval = new ContinuousDimensionInterval(minValue, maxValue, increment);
List <double> values = new List <double>()
{
21, 35, 42
};
Dimension discreteDimensionInterval = new DiscreteDimensionInterval(values);
double value = 72;
Dimension singleValueDimension = new SingleValueDimension(value);
IEnumerable <Dimension> dimensions = new List <Dimension>()
{
continuousDimensionInterval, discreteDimensionInterval, singleValueDimension
};
GetAllDimensionsModelView getAllDimensionsModelView = DimensionModelViewService.fromCollection(dimensions, "");
string minimumUnit = MeasurementUnitService.getMinimumUnit();
GetContinuousDimensionIntervalModelView continuousDimensionIntervalModelView = new GetContinuousDimensionIntervalModelView();
continuousDimensionIntervalModelView.minValue = minValue;
continuousDimensionIntervalModelView.maxValue = maxValue;
continuousDimensionIntervalModelView.increment = increment;
continuousDimensionIntervalModelView.unit = minimumUnit;
GetDiscreteDimensionIntervalModelView discreteDimensionIntervalModelView = new GetDiscreteDimensionIntervalModelView();
discreteDimensionIntervalModelView.values = values;
discreteDimensionIntervalModelView.unit = minimumUnit;
GetSingleValueDimensionModelView singleValueDimensionModelView = new GetSingleValueDimensionModelView();
singleValueDimensionModelView.value = value;
singleValueDimensionModelView.unit = minimumUnit;
GetAllDimensionsModelView expected = new GetAllDimensionsModelView()
{
continuousDimensionIntervalModelView, discreteDimensionIntervalModelView, singleValueDimensionModelView
};
for (int i = 0; i < 3; i++)
{
Assert.True(equalModelViews(getAllDimensionsModelView[i], expected[i]));
}
}
public void ensureFromModelViewCreatesSingleValueDimension()
{
AddSingleValueDimensionModelView singleValueDimensionModelView = new AddSingleValueDimensionModelView();
singleValueDimensionModelView.value = 124;
Dimension dimension = DimensionModelViewService.fromModelView(singleValueDimensionModelView);
Type singleValueDimensionType = typeof(SingleValueDimension);
Assert.Equal(singleValueDimensionType, dimension.GetType());
}
public void ensureFromEntityConvertsToGetDiscreteDimensionIntervalModelViewIfProvidedDimensionIsDiscreteInterval()
{
Dimension discreteDimensionInterval = new DiscreteDimensionInterval(new List <double>()
{
21, 35, 42
});
GetDimensionModelView getDimensionModelView = DimensionModelViewService.fromEntity(discreteDimensionInterval);
Type expectedDimensionType = typeof(GetDiscreteDimensionIntervalModelView);
Assert.Equal(expectedDimensionType, getDimensionModelView.GetType());
}
/// <summary>
/// Creates an instance of Measurement from an AddMeasurementModelView instance.
/// </summary>
/// <param name="measurementModelView">AddMeasurementModelView instance.</param>
/// <returns>Created Measurement.</returns>
public static Measurement fromModelView(AddMeasurementModelView measurementModelView)
{
if (measurementModelView == null)
{
throw new ArgumentException(ERROR_NULL_MEASUREMENT_VIEW);
}
Dimension heightDimension = DimensionModelViewService.fromModelView(measurementModelView.heightDimension);
Dimension widthDimension = DimensionModelViewService.fromModelView(measurementModelView.widthDimension);
Dimension depthDimension = DimensionModelViewService.fromModelView(measurementModelView.depthDimension);
return(new Measurement(heightDimension, widthDimension, depthDimension));
}
public void ensureFromEntityConvertsToGetContinuousDimensionIntervalModelViewIfProvidedDimensionIsContinuousInterval()
{
double minValue = 20;
double maxValue = 60;
double increment = 2;
Dimension continuousDimensionInterval = new ContinuousDimensionInterval(minValue, maxValue, increment);
GetDimensionModelView getDimensionModelView = DimensionModelViewService.fromEntity(continuousDimensionInterval);
Type expectedDimensionType = typeof(GetContinuousDimensionIntervalModelView);
Assert.Equal(expectedDimensionType, getDimensionModelView.GetType());
}
public void ensureFromModelViewCreatesContinuousDimensionInterval()
{
AddContinuousDimensionIntervalModelView continuousDimensionIntervalModelView = new AddContinuousDimensionIntervalModelView();
continuousDimensionIntervalModelView.minValue = 25;
continuousDimensionIntervalModelView.maxValue = 45;
continuousDimensionIntervalModelView.increment = 5;
Dimension dimension = DimensionModelViewService.fromModelView(continuousDimensionIntervalModelView);
Type continuousDimensionIntervalType = typeof(ContinuousDimensionInterval);
Assert.Equal(continuousDimensionIntervalType, dimension.GetType());
}
public void ensureFromModelViewCreatesDiscreteDimensionInterval()
{
AddDiscreteDimensionIntervalModelView discreteDimensionIntervalModelView = new AddDiscreteDimensionIntervalModelView();
discreteDimensionIntervalModelView.values = new List <double>()
{
12, 31, 45, 67
};
Dimension dimension = DimensionModelViewService.fromModelView(discreteDimensionIntervalModelView);
Type discreteDimensionIntervalType = typeof(DiscreteDimensionInterval);
Assert.Equal(discreteDimensionIntervalType, dimension.GetType());
}
public void ensureFromModelViewsCreatesEnumerableOfDimensionWithExpectedData()
{
string unit = "m";
double minValue = 20;
double maxValue = 120;
double increment = 5;
AddContinuousDimensionIntervalModelView continuousDimensionIntervalModelView = new AddContinuousDimensionIntervalModelView()
{
minValue = minValue,
maxValue = maxValue,
increment = increment,
unit = unit
};
List <double> values = new List <double>()
{
12, 31, 45, 67
};
AddDiscreteDimensionIntervalModelView discreteDimensionIntervalModelView = new AddDiscreteDimensionIntervalModelView();
discreteDimensionIntervalModelView.values = values;
discreteDimensionIntervalModelView.unit = unit;
IEnumerable <AddDimensionModelView> modelViews = new List <AddDimensionModelView>()
{
continuousDimensionIntervalModelView, discreteDimensionIntervalModelView
};
IEnumerable <Dimension> dimensions = DimensionModelViewService.fromModelViews(modelViews);
Assert.Equal(modelViews.Count(), dimensions.Count());
var modelViewEnumerator = modelViews.GetEnumerator();
var dimensionEnumerator = dimensions.GetEnumerator();
for (int i = 0; i < modelViews.Count(); i++)
{
modelViewEnumerator.MoveNext();
dimensionEnumerator.MoveNext();
Assert.True(modelViewEqualsDimension(modelViewEnumerator.Current, dimensionEnumerator.Current));
}
}
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 ensureFromEntityWithUnitConvertsToGetContinuousDimensionIntervalModelViewIfProvidedDimensionIsContinuousInterval()
{
Dimension continuousDimensionInterval = new ContinuousDimensionInterval(
minValue: 20,
maxValue: 60,
increment: 2
);
string unit = "dm";
GetDimensionModelView getDimensionModelView = DimensionModelViewService.fromEntity(continuousDimensionInterval, unit);
Type expectedDimensionType = typeof(GetContinuousDimensionIntervalModelView);
Assert.Equal(expectedDimensionType, getDimensionModelView.GetType());
}
public void ensureFromEntityConvertsSingleValueDimension()
{
Dimension singleValueDimension = new SingleValueDimension(15);
GetDimensionModelView getDimensionModelView = DimensionModelViewService.fromEntity(singleValueDimension);
GetSingleValueDimensionModelView expected = new GetSingleValueDimensionModelView();
expected.value = 15;
expected.unit = MeasurementUnitService.getMinimumUnit();
GetSingleValueDimensionModelView result = (GetSingleValueDimensionModelView)getDimensionModelView;
Assert.Equal(expected.value, result.value);
Assert.Equal(expected.unit, result.unit);
}
public void ensureFromEntityWithUnitConvertsSingleValueDimension()
{
double value = 15;
Dimension singleValueDimension = new SingleValueDimension(value);
string unit = "cm";
GetDimensionModelView getDimensionModelView = DimensionModelViewService.fromEntity(singleValueDimension, unit);
GetSingleValueDimensionModelView expected = new GetSingleValueDimensionModelView();
expected.value = MeasurementUnitService.convertToUnit(value, unit);
expected.unit = unit;
GetSingleValueDimensionModelView result = (GetSingleValueDimensionModelView)getDimensionModelView;
Assert.Equal(expected.value, result.value);
Assert.Equal(expected.unit, result.unit);
}
public void ensureFromEntityWithEmptyUnitUsesMinimumUnit()
{
double value = 15;
Dimension singleValueDimension = new SingleValueDimension(value);
string unit = "";
GetDimensionModelView getDimensionModelView = DimensionModelViewService.fromEntity(singleValueDimension, unit);
GetSingleValueDimensionModelView expected = new GetSingleValueDimensionModelView();
expected.value = value;
expected.unit = MeasurementUnitService.getMinimumUnit();
GetSingleValueDimensionModelView result = (GetSingleValueDimensionModelView)getDimensionModelView;
Assert.Equal(expected.value, result.value);
Assert.Equal(expected.unit, result.unit);
}
public void ensureFromEntityConvertsDiscreteDimensionInterval()
{
List <double> values = new List <double>()
{
21, 35, 42
};
Dimension discreteDimensionInterval = new DiscreteDimensionInterval(values);
GetDimensionModelView getDimensionModelView = DimensionModelViewService.fromEntity(discreteDimensionInterval);
GetDiscreteDimensionIntervalModelView result = (GetDiscreteDimensionIntervalModelView)getDimensionModelView;
GetDiscreteDimensionIntervalModelView expected = new GetDiscreteDimensionIntervalModelView();
expected.values = values;
expected.unit = MeasurementUnitService.getMinimumUnit();
Assert.Equal(expected.values, result.values);
Assert.Equal(expected.unit, result.unit);
}
public void ensureFromModelViewsThrowsExceptionIfElementIsNull()
{
string unit = "m";
double minValue = 20;
double maxValue = 120;
double increment = 5;
AddContinuousDimensionIntervalModelView continuousDimensionIntervalModelView = new AddContinuousDimensionIntervalModelView()
{
minValue = minValue,
maxValue = maxValue,
increment = increment,
unit = unit
};
List <double> values = new List <double>()
{
12, 31, 45, 67
};
AddDiscreteDimensionIntervalModelView discreteDimensionIntervalModelView = new AddDiscreteDimensionIntervalModelView();
discreteDimensionIntervalModelView.values = values;
discreteDimensionIntervalModelView.unit = unit;
AddDimensionModelView nullModelView = null;
IEnumerable <AddDimensionModelView> modelViews = new List <AddDimensionModelView>()
{
continuousDimensionIntervalModelView, discreteDimensionIntervalModelView, nullModelView
};
Action fromModelViews = () => DimensionModelViewService.fromModelViews(modelViews);
Assert.Throws <ArgumentNullException>(fromModelViews);
}
public void ensureFromEntityConvertsContinuousDimensionInterval()
{
double minValue = 20;
double maxValue = 60;
double increment = 2;
Dimension continuousDimensionInterval = new ContinuousDimensionInterval(minValue, maxValue, increment);
GetDimensionModelView getDimensionModelView = DimensionModelViewService.fromEntity(continuousDimensionInterval);
GetContinuousDimensionIntervalModelView result = (GetContinuousDimensionIntervalModelView)getDimensionModelView;
GetContinuousDimensionIntervalModelView expected = new GetContinuousDimensionIntervalModelView();
expected.minValue = minValue;
expected.maxValue = maxValue;
expected.increment = increment;
expected.unit = MeasurementUnitService.getMinimumUnit();
Assert.Equal(expected.minValue, result.minValue);
Assert.Equal(expected.maxValue, result.maxValue);
Assert.Equal(expected.increment, result.increment);
Assert.Equal(expected.unit, result.unit);
}
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);
}
}
public void ensureFromModelViewThrowsExceptionIfModelViewIsNull()
{
Action fromModelView = () => DimensionModelViewService.fromModelView(null);
Assert.Throws <ArgumentNullException>(fromModelView);
}
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);
}
