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);
}
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 ensureSameInstanceIsEqual()
{
var list = new List <double>();
list.Add(3.0);
DiscreteDimensionInterval instance = new DiscreteDimensionInterval(list);
Assert.True(instance.Equals(instance));
}
public void ensureApplyAllRestrictionsReturnsNullIfProductDoesNotObeyRestrictions()
{
ProductCategory cat = new ProductCategory("All Products");
Color black = Color.valueOf("Deep Black", 0, 0, 0, 0);
Color white = Color.valueOf("Blinding White", 255, 255, 255, 0);
List <Color> colors = new List <Color>()
{
black, white
};
Finish glossy = Finish.valueOf("Glossy", 100);
Finish matte = Finish.valueOf("Matte", 0);
List <Finish> finishes = new List <Finish>()
{
glossy, matte
};
Material material = new Material("#001", "Really Expensive Wood", "ola.jpg", colors, finishes);
Material material2 = new Material("#002", "Expensive Wood", "ola.jpg", colors, finishes);
Dimension heightDimension = new SingleValueDimension(50);
Dimension widthDimension = new DiscreteDimensionInterval(new List <double>()
{
60, 65, 70, 80, 90, 105
});
Dimension depthDimension = new ContinuousDimensionInterval(10, 25, 5);
Measurement measurement = new Measurement(heightDimension, widthDimension, depthDimension);
Product product = new Product("Test", "Shelf", "shelf.glb", cat, new List <Material>()
{
material, material2
}, new List <Measurement>()
{
measurement
}, ProductSlotWidths.valueOf(4, 4, 4));
Product product2 = new Product("Test", "Shelf", "shelf.glb", cat, new List <Material>()
{
material
}, new List <Measurement>()
{
measurement
}, ProductSlotWidths.valueOf(4, 4, 4));
CustomizedDimensions customDimension = CustomizedDimensions.valueOf(50, 80, 25);
CustomizedMaterial customMaterial = CustomizedMaterial.valueOf(material2, white, matte);
CustomizedProduct customizedProduct = CustomizedProductBuilder.createCustomizedProduct("reference", product, customDimension).build();
customizedProduct.changeCustomizedMaterial(customMaterial);
customizedProduct.finalizeCustomization();
RestrictableImpl instance = new RestrictableImpl();
instance.addRestriction(new Restriction("same material", new SameMaterialAndFinishAlgorithm()));
Assert.Null(instance.applyAllRestrictions(customizedProduct, product2));
}
public void ensureInstanceAndNullAreNotEqual()
{
var list = new List <double>();
list.Add(4.0);
DiscreteDimensionInterval instance = new DiscreteDimensionInterval(list);
Assert.False(instance.Equals(null));
}
/// <summary>
/// Creates a model view with a dimension information
/// </summary>
/// <param name="dimension">Dimension with the dimension being created the model view</param>
/// <param name="unit">Unit to which the values will be converted</param>
/// <returns>GetDimensionModelView with the dimension information model view</returns>
/// <exception cref="System.ArgumentNullException">Throw when the provided Dimension is null.</exception>
public static GetDimensionModelView fromEntity(Dimension dimension, string unit)
{
if (dimension == null)
{
throw new ArgumentNullException(ERROR_NULL_DIMENSION);
}
//if no unit is provided, use the default implementation
if (Strings.isNullOrEmpty(unit))
{
return(fromEntity(dimension));
}
Type dimensionType = dimension.GetType();
if (dimensionType == typeof(SingleValueDimension))
{
SingleValueDimension singleValueDimension = (SingleValueDimension)dimension;
GetSingleValueDimensionModelView singleMV = new GetSingleValueDimensionModelView();
singleMV.id = singleValueDimension.Id;
singleMV.unit = unit;
singleMV.value = MeasurementUnitService.convertToUnit(singleValueDimension.value, unit);
return(singleMV);
}
else if (dimensionType == typeof(DiscreteDimensionInterval))
{
DiscreteDimensionInterval discreteDimension = (DiscreteDimensionInterval)dimension;
GetDiscreteDimensionIntervalModelView discreteMV = new GetDiscreteDimensionIntervalModelView();
discreteMV.id = discreteDimension.Id;
discreteMV.unit = unit;
List <double> values = new List <double>();
foreach (double value in discreteDimension.values)
{
values.Add(MeasurementUnitService.convertToUnit(value, unit));
}
discreteMV.values = values;
return(discreteMV);
}
else if (dimensionType == typeof(ContinuousDimensionInterval))
{
ContinuousDimensionInterval continuousDimension = (ContinuousDimensionInterval)dimension;
GetContinuousDimensionIntervalModelView continuousMV = new GetContinuousDimensionIntervalModelView();
continuousMV.id = continuousDimension.Id;
continuousMV.unit = unit;
continuousMV.minValue = MeasurementUnitService.convertToUnit(continuousDimension.minValue, unit);
continuousMV.maxValue = MeasurementUnitService.convertToUnit(continuousDimension.maxValue, unit);
continuousMV.increment = MeasurementUnitService.convertToUnit(continuousDimension.increment, unit);
return(continuousMV);
}
else
{
throw new NotImplementedException(ERROR_NO_IMPLEMENTATION_UNKNOWN_DIMENSION);
}
}
public void ensureInstancesOfDifferentTypesAreNotEqual()
{
var list = new List <double>();
list.Add(2.0);
DiscreteDimensionInterval instance = new DiscreteDimensionInterval(list);
Assert.False(instance.Equals("Lil Pump"));
}
public void ensureInstancesWithSameListsAreEqual()
{
var list = new List <double>();
list.Add(33.0);
DiscreteDimensionInterval instance = new DiscreteDimensionInterval(list);
DiscreteDimensionInterval other = new DiscreteDimensionInterval(list);
Assert.True(instance.Equals(other));
}
public void testGetHashCode()
{
var list = new List <double>();
list.Add(30.0);
DiscreteDimensionInterval instance = new DiscreteDimensionInterval(list);
DiscreteDimensionInterval other = new DiscreteDimensionInterval(list);
Assert.Equal(instance.GetHashCode(), other.GetHashCode());
}
public void testToDTO()
{
var list = new List <double>();
list.Add(1.234);
DiscreteDimensionInterval instance = new DiscreteDimensionInterval(list);
DiscreteDimensionInterval other = new DiscreteDimensionInterval(list);
Assert.Equal(instance.toDTO().ToString(), other.toDTO().ToString());
}
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 ensureInstancesWithDifferentListsAreNotEqual()
{
var list = new List <double>();
var otherList = new List <double>();
list.Add(6.9);
otherList.Add(4.20);
DiscreteDimensionInterval instance = new DiscreteDimensionInterval(list);
DiscreteDimensionInterval other = new DiscreteDimensionInterval(otherList);
Assert.False(instance.Equals(other));
}
public void ensureToDTOWithNullUnitStringDefaultsToMilimetres()
{
var values = new List <double>()
{
12.5, 13, 13.5, 14, 14.5, 15, 16, 17
};
DiscreteDimensionInterval instance = new DiscreteDimensionInterval(values);
DiscreteDimensionIntervalDTO dto = (DiscreteDimensionIntervalDTO)instance.toDTO(null);
Assert.Equal("mm", dto.unit);
}
public void ensureDiscreteDimensionIntervalDoesNotHaveValue()
{
List <double> values = new List <double>();
values.Add(12);
values.Add(13);
values.Add(13.5);
values.Add(14);
DiscreteDimensionInterval discreteDimension = new DiscreteDimensionInterval(values);
Assert.False(discreteDimension.hasValue(15));
}
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());
}
public void ensureGetValuesAsArrayWorks()
{
var values = new List <double>()
{
12.5, 13, 13.5, 14, 14.5, 15, 16, 17
};
DiscreteDimensionInterval instance = new DiscreteDimensionInterval(values);
double[] expectedValues = { 12.5, 13, 13.5, 14, 14.5, 15, 16, 17 };
Assert.Equal(expectedValues, instance.getValuesAsArray());
}
public void ensureDiscretDimensioIntervalHasValue()
{
List <double> values = new List <double>();
values.Add(12);
values.Add(13);
values.Add(13.5);
values.Add(14);
DiscreteDimensionInterval discreteDimension = new DiscreteDimensionInterval(values);
Assert.True(discreteDimension.hasValue(13.5));
}
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);
}
}
/// <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);
}
public void ensureDiscreteDimensionIntervalGetMinValueIsTheSameAsTheLowestValueOnTheCollection()
{
double minValue = 12;
List <double> values = new List <double>();
values.Add(minValue);
values.Add(13);
values.Add(13.5);
values.Add(14);
DiscreteDimensionInterval discreteDimension = new DiscreteDimensionInterval(values);
double obtainedMinValue = discreteDimension.getMinValue();
Assert.Equal(minValue, obtainedMinValue, 0);
}
public void ensureToDTOConvertsValuesToGivenUnit()
{
var values = new List <double>()
{
12.5, 13, 13.5, 14, 14.5, 15, 16, 17
};
DiscreteDimensionInterval instance = new DiscreteDimensionInterval(values);
DiscreteDimensionIntervalDTO dto = (DiscreteDimensionIntervalDTO)instance.toDTO("cm");
var expectedValues = new List <double>()
{
1.25, 1.3, 1.35, 1.4, 1.45, 1.5, 1.6, 1.7
};
Assert.Equal(expectedValues, dto.values);
}
public void ensureToDTOWithNullStringDoesNotConvertValues()
{
var values = new List <double>()
{
12.5, 13, 13.5, 14, 14.5, 15, 16, 17
};
DiscreteDimensionInterval instance = new DiscreteDimensionInterval(values);
DiscreteDimensionIntervalDTO dto = (DiscreteDimensionIntervalDTO)instance.toDTO(null);
var expectedValues = new List <double>()
{
12.5, 13, 13.5, 14, 14.5, 15, 16, 17
};
Assert.Equal(expectedValues, dto.values);
}
private CustomizedProduct buildCustomizedProduct(string customizedProductReference)
{
var category = new ProductCategory("Drawers");
//Creating Dimensions
List <Double> values2 = new List <Double>();
values2.Add(500.0); //Width
DiscreteDimensionInterval d2 = new DiscreteDimensionInterval(values2);
Measurement measurement = new Measurement(d2, d2, d2);
List <Measurement> measurements = new List <Measurement>()
{
measurement
};
//Creating a material
string reference = "1160912";
string designation = "FR E SH A VOCA DO";
List <Color> colors = new List <Color>();
Color color = Color.valueOf("AND READ-ER-BIBLE", 1, 2, 3, 0);
colors.Add(color);
List <Finish> finishes = new List <Finish>();
Finish finish = Finish.valueOf("Amém", 12);
finishes.Add(finish);
Material material = new Material(reference, designation, "ola.jpg", colors, finishes);
List <Material> materials = new List <Material>();
materials.Add(material);
IEnumerable <Material> matsList = materials;
Product product = new Product("#666", "Shelf", "shelf666.glb", category, matsList, measurements);
CustomizedDimensions customizedDimensions = CustomizedDimensions.valueOf(500.0, 500.0, 500.0);
//Customized Material
CustomizedMaterial custMaterial1 = CustomizedMaterial.valueOf(material, color, finish);
return(CustomizedProductBuilder.createCustomizedProduct(customizedProductReference, product, customizedDimensions).withMaterial(custMaterial1).build());
}
public void ensureApplyRemovesUnnecessaryFinishes()
{
Console.WriteLine("ensureApplyRemovesUnnecessaryFinishes");
Material material = new Material("#24", "K6205", "ola.jpg", new List <Color>(new[] { Color.valueOf("Epigraph of the Closed Curve: Close Epigraph", 100, 100, 100, 100) }), new List <Finish>(new[] { Finish.valueOf("der alte wurfelt nicht", 12), Finish.valueOf("schrödinger's box", 13) }));
ProductCategory cat = new ProductCategory("AI");
DiscreteDimensionInterval discrete = new DiscreteDimensionInterval(new List <double>(new[] { 50.0, 90.0, 100.0, 150.0 }));
Measurement measurement = new Measurement(discrete, discrete, discrete);
List <Measurement> measurements = new List <Measurement>()
{
measurement
};
Product product = new Product("#12", "Mother Goose of Mutual Recursion: Recursive Mother Goose", "product12.glb", cat, new List <Material>(new[] { material }), measurements);
Product component = new Product("#13", "Mother Goose of Diffractive Recitavo: Diffraction Mother Goose", "product13.gltf", cat, new List <Material>(new[] { material }), measurements);
CustomizedProduct custom = CustomizedProductBuilder.createCustomizedProduct("#8", product, CustomizedDimensions.valueOf(100, 100, 100)).withMaterial(CustomizedMaterial.valueOf(material, Color.valueOf("Epigraph of the Closed Curve: Close Epigraph", 100, 100, 100, 100), Finish.valueOf("schrödinger's box", 13))).build();
Algorithm algorithm = new AlgorithmFactory().createAlgorithm(RestrictionAlgorithm.SAME_MATERIAL_AND_FINISH_ALGORITHM);
Assert.Equal("schrödinger's box", algorithm.apply(custom, component).productMaterials[0].material.Finishes[0].description);
}
public void ensureApplyWorks()
{
Restriction instance = new Restriction("oh hi mark", new SameMaterialAndFinishAlgorithm());
Material material = new Material("#24", "K6205", "ola.jpg", new List <Color>(new[] { Color.valueOf("Epigraph of the Closed Curve: Close Epigraph", 100, 100, 100, 100) }), new List <Finish>(new[] { Finish.valueOf("der alte wurfelt nicht", 12) }));
Material material1 = new Material("#22", "Amadeus", "ola.jpg", new List <Color>(new[] { Color.valueOf("Epigraph of the Closed Curve: Close Epigraph", 100, 100, 100, 100) }), new List <Finish>(new[] { Finish.valueOf("der alte wurfelt nicht", 12) }));
ProductCategory cat = new ProductCategory("AI");
DiscreteDimensionInterval discrete = new DiscreteDimensionInterval(new List <double>(new[] { 50.0, 90.0, 100.0, 150.0 }));
Measurement measurement = new Measurement(discrete, discrete, discrete);
List <Measurement> measurements = new List <Measurement>()
{
measurement
};
Product product = new Product("#12", "Mother Goose of Mutual Recursion: Recursive Mother Goose", "product12.glb", cat, new List <Material>(new[] { material }), measurements);
Product component = new Product("#13", "Mother Goose of Diffractive Recitavo: Diffraction Mother Goose", "product13.gltf", cat, new List <Material>(new[] { material1, material }), measurements);
CustomizedProduct custom = CustomizedProductBuilder.createCustomizedProduct("#8", product, CustomizedDimensions.valueOf(100, 100, 100)).withMaterial(CustomizedMaterial.valueOf(material, Color.valueOf("Epigraph of the Closed Curve: Close Epigraph", 100, 100, 100, 100), Finish.valueOf("der alte wurfelt nicht", 12))).build();
Assert.True(instance.applyAlgorithm(custom, component).productMaterials[0].material.Equals(material));
}
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 ensureApplyRemovesDiscreteDimensions()
{
Color color = Color.valueOf("Durpa", 100, 100, 100, 100);
Finish finish = Finish.valueOf("der alte wurfelt nicht", 35);
Material material = new Material("#12", "K6205", "12.jpg", new List <Color>(new[] { color }), new List <Finish>(new[] { finish }));
ProductCategory cat = new ProductCategory("AI");
DiscreteDimensionInterval discrete = new DiscreteDimensionInterval(new List <double>(new[] { 50.0, 110.0, 150.0 }));
DiscreteDimensionInterval discrete2 = new DiscreteDimensionInterval(new List <double>(new[] { 50.0, 150.0, 150.0 }));
Measurement measurement = new Measurement(new SingleValueDimension(200), discrete, new SingleValueDimension(50));
Measurement measurement2 = new Measurement(new SingleValueDimension(200), discrete2, new SingleValueDimension(50));
List <Measurement> measurements = new List <Measurement>()
{
measurement
};
List <Measurement> measurements2 = new List <Measurement>()
{
measurement2
};
Product component = new Product("#10", "Pandora of Provable Existence: Forbidden Cubicle", "10.gltf", cat, new List <Material>(new[] { material }), measurements2);
Product product = new Product("#9", "Pandora of Eternal Return: Pandora's Box", "9.fbx", cat, new List <Material>(new[] { material }), measurements, new List <Product>()
{
component
});
CustomizedDimensions customizedDimensions = CustomizedDimensions.valueOf(200, 110, 50);
CustomizedMaterial customizedMaterial = CustomizedMaterial.valueOf(material, color, finish);
CustomizedProduct custom = CustomizedProductBuilder.createCustomizedProduct("12345", product, customizedDimensions).withMaterial(customizedMaterial).build();
WidthPercentageAlgorithm algorithm = new WidthPercentageAlgorithm();
Input minInput = Input.valueOf("Minimum Percentage", "From 0 to 1");
Input maxInput = Input.valueOf("Maximum Percentage", "From 0 to 1");
Dictionary <Input, string> inputs = new Dictionary <Input, string>();
inputs.Add(minInput, "0.9");
inputs.Add(maxInput, "1.0");
algorithm.setInputValues(inputs);
Assert.Null(algorithm.apply(custom, component));
}
public void ensureApplyAllRestrictionsReturnsNullIfCustomizedProductArgumentNull()
{
ProductCategory cat = new ProductCategory("All Products");
Color black = Color.valueOf("Deep Black", 0, 0, 0, 0);
Color white = Color.valueOf("Blinding White", 255, 255, 255, 0);
List <Color> colors = new List <Color>()
{
black, white
};
Finish glossy = Finish.valueOf("Glossy", 100);
Finish matte = Finish.valueOf("Matte", 0);
List <Finish> finishes = new List <Finish>()
{
glossy, matte
};
Material material = new Material("#001", "Really Expensive Wood", "ola.jpg", colors, finishes);
Dimension heightDimension = new SingleValueDimension(50);
Dimension widthDimension = new DiscreteDimensionInterval(new List <double>()
{
60, 65, 70, 80, 90, 105
});
Dimension depthDimension = new ContinuousDimensionInterval(10, 25, 5);
Measurement measurement = new Measurement(heightDimension, widthDimension, depthDimension);
Product product = new Product("Test", "Shelf", "shelf.glb", cat, new List <Material>()
{
material
}, new List <Measurement>()
{
measurement
}, ProductSlotWidths.valueOf(4, 4, 4));
Assert.Null(new RestrictableImpl().applyAllRestrictions(null, product));
}
public void ensureApplyRemovesValuesFromDiscreteDimensions()
{
Color color = Color.valueOf("Epigraph of the Closed Curve: Close Epigraph", 100, 100, 100, 100);
Finish finish = Finish.valueOf("der alte wurfelt nicht", 20);
Material material = new Material("#24", "K6205", "12.jpg", new List <Color>(new[] { color }), new List <Finish>(new[] { finish }));
ProductCategory cat = new ProductCategory("AI");
DiscreteDimensionInterval discrete = new DiscreteDimensionInterval(new List <double>(new[] { 50.0, 90.0, 100.0, 150.0 }));
Measurement measurement = new Measurement(new SingleValueDimension(200), discrete, new SingleValueDimension(50));
List <Measurement> measurements = new List <Measurement>()
{
measurement
};
Product component = new Product("#13", "Mother Goose of Diffractive Recitavo: Diffraction Mother Goose", "13.glb", cat, new List <Material>(new[] { material }), measurements);
Product product = new Product("#12", "Mother Goose of Mutual Recursion: Recursive Mother Goose ", "12.fbx", cat, new List <Material>(new[] { material }), measurements, new List <Product>()
{
component
});
CustomizedMaterial customizedMaterial = CustomizedMaterial.valueOf(material, color, finish);
CustomizedDimensions customizedDimensions = CustomizedDimensions.valueOf(200, 100, 50);
CustomizedProduct custom = CustomizedProductBuilder.createCustomizedProduct("12345", product, customizedDimensions).withMaterial(customizedMaterial).build();
WidthPercentageAlgorithm algorithm = new WidthPercentageAlgorithm();
Input minInput = Input.valueOf("Minimum Percentage", "From 0 to 1");
Input maxInput = Input.valueOf("Maximum Percentage", "From 0 to 1");
Dictionary <Input, string> inputs = new Dictionary <Input, string>();
inputs.Add(minInput, "0.9");
inputs.Add(maxInput, "1.0");
algorithm.setInputValues(inputs);
Product alteredProduct = algorithm.apply(custom, component);
DiscreteDimensionInterval discreteDimension = (DiscreteDimensionInterval)alteredProduct.productMeasurements[0].measurement.width;
DiscreteDimensionInterval expected = new DiscreteDimensionInterval(new List <double>(new[] { 90.0, 100.0 }));
Assert.True(discreteDimension.Equals(expected));
}
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);
}
}
