private void SetSoilProfileChartData()
{
PipingSoilProfile soilProfile = data.InputParameters.StochasticSoilProfile?.SoilProfile;
// If necessary, regenerate all soil layer chart data
if (!ReferenceEquals(currentSoilProfile, soilProfile))
{
currentSoilProfile = soilProfile;
soilProfileChartData.Clear();
soilLayerChartDataLookup.Clear();
GetSoilLayers().Select(PipingChartDataFactory.CreateSoilLayerChartData)
.ForEachElementDo(sl =>
{
soilProfileChartData.Insert(0, sl);
soilLayerChartDataLookup.Add(sl);
});
PipingChartDataFactory.UpdateSoilProfileChartDataName(soilProfileChartData, currentSoilProfile);
}
// Update the areas of all soil layer chart data
IEnumerable <PipingSoilLayer> soilLayers = GetSoilLayers();
for (var i = 0; i < soilLayers.Count(); i++)
{
ChartMultipleAreaData soilLayerData = soilLayerChartDataLookup[i];
soilLayerData.Areas = PipingChartDataPointsFactory.CreateSoilLayerAreas(soilLayers.ElementAt(i), currentSoilProfile, data.InputParameters.SurfaceLine);
}
}
public void GivenChartMultipleAreaDataSeries_WhenUpdatedAfterChartMultipleAreaDataAreasChanged_ChartMultipleAreaDataSeriesAreasChanged()
{
// Given
var chartMultipleAreaData = new ChartMultipleAreaData("Test name")
{
Areas = new[]
{
new[]
{
new Point2D(1.1, 2.2)
}
}
};
var chartMultipleAreaDataSeries = new ChartMultipleAreaDataSeries(chartMultipleAreaData);
IEnumerable <DataPoint>[] drawnAreas = chartMultipleAreaDataSeries.Areas.ToArray();
// When
chartMultipleAreaData.Areas = new[]
{
new[]
{
new Point2D(3.3, 4.4)
}
};
chartMultipleAreaDataSeries.Update();
// Then
CollectionAssert.AreNotEqual(drawnAreas, chartMultipleAreaDataSeries.Areas);
}
public void OnDrop_ChartDataMovedToPositionOutsideRange_ThrowsException(int position)
{
// Setup
var observer = mocks.StrictMock <IObserver>();
mocks.ReplayAll();
var chartData1 = new ChartLineData("line");
var chartData2 = new ChartAreaData("area");
var chartData3 = new ChartPointData("point");
var chartData4 = new ChartMultipleAreaData("multiple area");
var chartDataCollection = new ChartDataCollection("test data");
chartDataCollection.Add(chartData1);
chartDataCollection.Add(chartData2);
chartDataCollection.Add(chartData3);
chartDataCollection.Add(chartData4);
chartDataCollection.Attach(observer);
chartLegendView.Data = chartDataCollection;
ChartDataContext context1 = GetContext(chartData1);
chartDataCollection.Attach(observer);
using (var treeViewControl = new TreeViewControl())
{
// Call
void Call() => info.OnDrop(context1, chartDataCollection, chartDataCollection, position, treeViewControl);
// Assert
Assert.Throws <ArgumentOutOfRangeException>(Call);
}
}
public void CreateSlicesChartData_ReturnsChartMultipleAreaData()
{
// Call
ChartMultipleAreaData data = MacroStabilityInwardsSliceChartDataFactory.CreateSlicesChartData();
// Assert
CollectionAssert.IsEmpty(data.Areas);
Assert.AreEqual("Lamellen", data.Name);
AssertEqualStyle(data.Style, Color.Empty, Color.DarkGreen, 2, true);
}
private void SetSoilLayerAreas()
{
var i = 0;
foreach (MacroStabilityInwardsSoilLayer2D soilLayer in GetSoilLayers().Reverse())
{
ChartMultipleAreaData soilLayerData = soilLayerChartDataLookup[i++];
soilLayerData.Areas = MacroStabilityInwardsChartDataPointsFactory.CreateOuterRingArea(soilLayer);
}
}
public void CreateEffectiveStressChartData_ReturnsChartMultipleAreaData()
{
// Call
ChartMultipleAreaData data = MacroStabilityInwardsSliceChartDataFactory.CreateEffectiveStressChartData();
// Assert
CollectionAssert.IsEmpty(data.Areas);
Assert.AreEqual("Effectieve spanning", data.Name);
Assert.IsTrue(data.IsVisible);
AssertEqualStyle(data.Style, Color.FromArgb(150, 255, 0, 0), Color.Black, 1, true);
}
public void CreateWeightChartData_ReturnsChartMultipleAreaData()
{
// Call
ChartMultipleAreaData data = MacroStabilityInwardsSliceChartDataFactory.CreateWeightChartData();
// Assert
CollectionAssert.IsEmpty(data.Areas);
Assert.AreEqual("Gewicht", data.Name);
Assert.IsFalse(data.IsVisible);
AssertEqualStyle(data.Style, Color.FromArgb(150, 255, 0, 0), Color.Black, 1, true);
}
/// <summary>
/// Creates a new instance of <see cref="ChartMultipleAreaDataSeries"/>.
/// </summary>
/// <param name="chartMultipleAreaData">The <see cref="ChartMultipleAreaData"/> which the chart multiple area data series is based upon.</param>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="chartMultipleAreaData"/> is <c>null</c>.</exception>
public ChartMultipleAreaDataSeries(ChartMultipleAreaData chartMultipleAreaData)
{
if (chartMultipleAreaData == null)
{
throw new ArgumentNullException(nameof(chartMultipleAreaData));
}
this.chartMultipleAreaData = chartMultipleAreaData;
Update();
}
public void Constructor_Always_CreatesNewInstanceOfDefaultStyle()
{
// Setup
var dataA = new ChartMultipleAreaData("test data");
// Call
var dataB = new ChartMultipleAreaData("test data");
// Assert
Assert.AreNotSame(dataA.Style, dataB.Style);
}
public void CreateHorizontalPorePressureChartData_ReturnsChartMultipleAreaData()
{
// Call
ChartMultipleAreaData data = MacroStabilityInwardsSliceChartDataFactory.CreateHorizontalPorePressureChartData();
// Assert
CollectionAssert.IsEmpty(data.Areas);
Assert.AreEqual("Horizontale waterspanning op maaiveld", data.Name);
Assert.IsFalse(data.IsVisible);
AssertEqualStyle(data.Style, Color.FromArgb(150, 255, 0, 0), Color.Black, 1, true);
}
private static void SetChartMultipleAreaDataTestProperties(ChartMultipleAreaData chartMultipleAreaData)
{
chartMultipleAreaData.Name = "Another name";
chartMultipleAreaData.IsVisible = false;
chartMultipleAreaData.Areas = new[]
{
new[]
{
new Point2D(1.1, 2.2)
}
};
}
public void Areas_SetValidNewValue_GetsNewValue()
{
// Setup
var data = new ChartMultipleAreaData("test data");
var areas = new List <Point2D[]>();
// Call
data.Areas = areas;
// Assert
Assert.AreSame(areas, data.Areas);
}
public void CanDrag_WrappedDataChartMultipleAreaData_ReturnsFalse()
{
// Setup
var multipleChartAreaData = new ChartMultipleAreaData("test");
ChartDataContext context = GetContext(multipleChartAreaData);
// Call
bool canDrag = info.CanDrag(context, null);
// Assert
Assert.IsFalse(canDrag);
}
public void Areas_SetNullValue_ThrowsArgumentNullException()
{
// Setup
var data = new ChartMultipleAreaData("test data");
// Call
TestDelegate test = () => data.Areas = null;
// Assert
const string expectedMessage = "The collection of point arrays cannot be null.";
TestHelper.AssertThrowsArgumentExceptionAndTestMessage <ArgumentNullException>(test, expectedMessage);
}
public void Constructor_ValidName_NameAndDefaultValuesSet()
{
// Call
var data = new ChartMultipleAreaData("test data");
// Assert
Assert.AreEqual("test data", data.Name);
Assert.IsInstanceOf <ChartData>(data);
Assert.AreEqual(Color.Gray, data.Style.FillColor);
Assert.AreEqual(Color.Black, data.Style.StrokeColor);
Assert.AreEqual(2, data.Style.StrokeThickness);
Assert.IsFalse(data.Style.IsEditable);
}
public void CreateWaternetZoneChartData_WithVisibility_ReturnsEmptyChartLineDataWithExpectedStylingAndVisibility(bool isVisible)
{
// Setup
const string name = "zone";
// Call
ChartMultipleAreaData data = MacroStabilityInwardsChartDataFactory.CreateWaternetZoneChartData(name, isVisible);
// Assert
CollectionAssert.IsEmpty(data.Areas);
Assert.AreEqual(name, data.Name);
Assert.AreEqual(isVisible, data.IsVisible);
AssertEqualStyle(data.Style, Color.FromArgb(60, Color.DeepSkyBlue), Color.Empty, 0, true);
}
public void Constructor_WithStyle_ExpectedValue()
{
// Setup
var style = new ChartAreaStyle();
// Call
var data = new ChartMultipleAreaData("test data", style);
// Assert
Assert.AreEqual("test data", data.Name);
CollectionAssert.IsEmpty(data.Areas);
Assert.IsInstanceOf <ChartData>(data);
Assert.AreSame(style, data.Style);
}
public void CreateSoilLayerChartData_LayerWithEmptyNameAndColor_ReturnsEmptyChartDataCollectionWithExpectedStyling()
{
// Call
ChartMultipleAreaData data = PipingChartDataFactory.CreateSoilLayerChartData(new PipingSoilLayer(0)
{
MaterialName = string.Empty,
Color = Color.Empty
});
// Assert
CollectionAssert.IsEmpty(data.Areas);
Assert.AreEqual("Onbekend", data.Name);
AssertEqualStyle(data.Style, Color.White, Color.Black, 1);
}
public void CreateSoilLayerChartData_LayerWithEmptyNameAndColor_ReturnsEmptyChartDataCollectionWithExpectedStyling()
{
// Setup
MacroStabilityInwardsSoilLayer2D layer = MacroStabilityInwardsSoilLayer2DTestFactory.CreateMacroStabilityInwardsSoilLayer2D();
layer.Data.MaterialName = string.Empty;
layer.Data.Color = Color.Empty;
// Call
ChartMultipleAreaData data = MacroStabilityInwardsChartDataFactory.CreateSoilLayerChartData(layer);
// Assert
CollectionAssert.IsEmpty(data.Areas);
Assert.AreEqual("Onbekend", data.Name);
AssertEqualStyle(data.Style, Color.White, Color.Black, 1, false);
}
public void Constructor_Always_PropertiesHaveExpectedAttributesValues(bool isStyleEditable)
{
// Setup
var chartAreaData = new ChartMultipleAreaData("Test", new ChartAreaStyle
{
IsEditable = isStyleEditable
});
// Call
var properties = new ChartMultipleAreaDataProperties
{
Data = chartAreaData
};
// Assert
PropertyDescriptorCollection dynamicProperties = PropertiesTestHelper.GetAllVisiblePropertyDescriptors(properties);
Assert.AreEqual(6, dynamicProperties.Count);
const string styleCategory = "Stijl";
PropertyDescriptor fillColorProperty = dynamicProperties[fillColorPropertyIndex];
Assert.IsInstanceOf <ColorTypeConverter>(fillColorProperty.Converter);
PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(fillColorProperty,
styleCategory,
"Kleur",
"De kleur van de vlakken waarmee deze gegevensreeks wordt weergegeven.",
!isStyleEditable);
PropertyDescriptor strokeColorProperty = dynamicProperties[strokeColorPropertyIndex];
Assert.IsInstanceOf <ColorTypeConverter>(strokeColorProperty.Converter);
PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(strokeColorProperty,
styleCategory,
"Lijnkleur",
"De kleur van de lijn van de vlakken waarmee deze gegevensreeks wordt weergegeven.",
!isStyleEditable);
PropertyDescriptor strokeThicknessProperty = dynamicProperties[strokeThicknessPropertyIndex];
PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(strokeThicknessProperty,
styleCategory,
"Lijndikte",
"De dikte van de lijn van de vlakken waarmee deze gegevensreeks wordt weergegeven.",
!isStyleEditable);
}
public void CreateSoilLayerChartData_WithLayer_ReturnsEmptyChartDataCollectionWithExpectedStyling()
{
// Setup
const string name = "Soil layer test name";
Color fillColor = Color.Firebrick;
// Call
ChartMultipleAreaData data = PipingChartDataFactory.CreateSoilLayerChartData(new PipingSoilLayer(0)
{
MaterialName = name,
Color = fillColor
});
// Assert
CollectionAssert.IsEmpty(data.Areas);
Assert.AreEqual(name, data.Name);
AssertEqualStyle(data.Style, fillColor, Color.Black, 1);
}
public void ConvertSeriesProperties_ChartAreaStyleSetWithDifferentStrokeWidths_AppliesStyleToSeries(int width)
{
// Setup
var converter = new ChartMultipleAreaDataConverter();
var multipleAreaSeries = new MultipleAreaSeries();
var data = new ChartMultipleAreaData("test", new ChartAreaStyle
{
FillColor = Color.Red,
StrokeColor = Color.Red,
StrokeThickness = width
});
// Call
converter.ConvertSeriesProperties(data, multipleAreaSeries);
// Assert
Assert.AreEqual(width, multipleAreaSeries.StrokeThickness);
}
public void CreateSoilLayerChartData_WithLayer_ReturnsEmptyChartDataCollectionWithExpectedStyling()
{
// Setup
const string name = "Soil layer test name";
Color fillColor = Color.Firebrick;
MacroStabilityInwardsSoilLayer2D layer = MacroStabilityInwardsSoilLayer2DTestFactory.CreateMacroStabilityInwardsSoilLayer2D();
layer.Data.MaterialName = name;
layer.Data.Color = fillColor;
// Call
ChartMultipleAreaData data = MacroStabilityInwardsChartDataFactory.CreateSoilLayerChartData(layer);
// Assert
CollectionAssert.IsEmpty(data.Areas);
Assert.AreEqual(name, data.Name);
AssertEqualStyle(data.Style, fillColor, Color.Black, 1, false);
}
private static void SetWaternetZonesChartData(MacroStabilityInwardsWaternet waternet, MacroStabilityInwardsSurfaceLine surfaceLine,
ChartDataCollection chartData)
{
chartData.Clear();
foreach (MacroStabilityInwardsPhreaticLine phreaticLine in waternet.PhreaticLines)
{
ChartLineData phreaticLineChartData = MacroStabilityInwardsChartDataFactory.CreatePhreaticLineChartData(phreaticLine.Name, true);
phreaticLineChartData.Points = MacroStabilityInwardsChartDataPointsFactory.CreatePhreaticLinePoints(phreaticLine);
chartData.Add(phreaticLineChartData);
}
foreach (MacroStabilityInwardsWaternetLine waternetLine in waternet.WaternetLines)
{
ChartMultipleAreaData waternetLineChartData = MacroStabilityInwardsChartDataFactory.CreateWaternetZoneChartData(waternetLine.Name, true);
waternetLineChartData.Areas = MacroStabilityInwardsChartDataPointsFactory.CreateWaternetZonePoints(waternetLine, surfaceLine);
chartData.Add(waternetLineChartData);
}
}
public void ConvertSeriesProperties_ChartAreaStyleSetWithDifferentFillColors_AppliesStyleToSeries(KnownColor color)
{
// Setup
var converter = new ChartMultipleAreaDataConverter();
var multipleAreaSeries = new MultipleAreaSeries();
Color expectedColor = Color.FromKnownColor(color);
var data = new ChartMultipleAreaData("test", new ChartAreaStyle
{
FillColor = expectedColor,
StrokeColor = Color.Red,
StrokeThickness = 3
});
// Call
converter.ConvertSeriesProperties(data, multipleAreaSeries);
// Assert
AssertColors(expectedColor, multipleAreaSeries.Fill);
}
public void Constructor_ChartMultipleAreaDataWithTestProperties_ChartMultipleAreaDataSeriesCreatedAccordingly()
{
// Setup
var chartMultipleAreaData = new ChartMultipleAreaData("Test name", new ChartAreaStyle
{
FillColor = fillColor,
StrokeColor = strokeColor,
StrokeThickness = 3
});
SetChartMultipleAreaDataTestProperties(chartMultipleAreaData);
// Call
var chartMultipleAreaDataSeries = new ChartMultipleAreaDataSeries(chartMultipleAreaData);
// Assert
Assert.IsInstanceOf <MultipleAreaSeries>(chartMultipleAreaDataSeries);
Assert.IsInstanceOf <IChartDataSeries>(chartMultipleAreaDataSeries);
AssertChartMultipleAreaDataSeriesTestProperties(chartMultipleAreaDataSeries);
}
public void SetProperties_IndividualProperties_UpdateDataAndNotifyObservers()
{
// Setup
const int numberOfChangedProperties = 3;
var mocks = new MockRepository();
var observer = mocks.StrictMock <IObserver>();
observer.Expect(o => o.UpdateObserver()).Repeat.Times(numberOfChangedProperties);
mocks.ReplayAll();
var chartAreaData = new ChartMultipleAreaData("Test", new ChartAreaStyle
{
FillColor = Color.AliceBlue,
StrokeColor = Color.Blue,
StrokeThickness = 3
});
chartAreaData.Attach(observer);
var properties = new ChartMultipleAreaDataProperties
{
Data = chartAreaData
};
Color newFillColor = Color.Blue;
Color newStrokeColor = Color.Red;
const int newStrokeThickness = 6;
// Call
properties.FillColor = newFillColor;
properties.StrokeColor = newStrokeColor;
properties.StrokeThickness = newStrokeThickness;
// Assert
Assert.AreEqual(newFillColor, chartAreaData.Style.FillColor);
Assert.AreEqual(newStrokeColor, chartAreaData.Style.StrokeColor);
Assert.AreEqual(newStrokeThickness, chartAreaData.Style.StrokeThickness);
mocks.VerifyAll();
}
public void Update_ChartMultipleAreaDataWithTestProperties_ChartMultipleAreaDataSeriesUpdatedAccordingly()
{
// Setup
var chartMultipleAreaData = new ChartMultipleAreaData("Test name", new ChartAreaStyle
{
FillColor = fillColor,
StrokeColor = strokeColor,
StrokeThickness = 3
});
var chartMultipleAreaDataSeries = new ChartMultipleAreaDataSeries(chartMultipleAreaData);
SetChartMultipleAreaDataTestProperties(chartMultipleAreaData);
// Precondition
AssertChartMultipleAreaDataSeriesDefaultProperties(chartMultipleAreaDataSeries);
// Call
chartMultipleAreaDataSeries.Update();
// Assert
AssertChartMultipleAreaDataSeriesTestProperties(chartMultipleAreaDataSeries);
}
private static void SetWaternetZonesChartData(MacroStabilityInwardsWaternet waternet, ChartDataCollection chartData,
IDictionary <MacroStabilityInwardsPhreaticLine, ChartLineData> phreaticLineLookup,
IDictionary <MacroStabilityInwardsWaternetLine, ChartMultipleAreaData> waternetLineLookup)
{
chartData.Clear();
phreaticLineLookup.Clear();
waternetLineLookup.Clear();
foreach (MacroStabilityInwardsPhreaticLine phreaticLine in waternet.PhreaticLines)
{
ChartLineData phreaticLineChartData = MacroStabilityInwardsChartDataFactory.CreatePhreaticLineChartData(phreaticLine.Name, false);
chartData.Add(phreaticLineChartData);
phreaticLineLookup.Add(phreaticLine, phreaticLineChartData);
}
foreach (MacroStabilityInwardsWaternetLine waternetLine in waternet.WaternetLines)
{
ChartMultipleAreaData waternetLineChartData = MacroStabilityInwardsChartDataFactory.CreateWaternetZoneChartData(waternetLine.Name, false);
chartData.Add(waternetLineChartData);
waternetLineLookup.Add(waternetLine, waternetLineChartData);
}
}
public void Data_SetNewChartAreaDataInstance_ReturnCorrectPropertyValues()
{
// Setup
Color fillColor = Color.Aqua;
Color strokeColor = Color.Bisque;
const int strokeThickness = 4;
var chartAreaData = new ChartMultipleAreaData("Test", new ChartAreaStyle
{
FillColor = fillColor,
StrokeColor = strokeColor,
StrokeThickness = strokeThickness
});
var properties = new ChartMultipleAreaDataProperties();
// Call
properties.Data = chartAreaData;
// Assert
Assert.AreEqual(fillColor, properties.FillColor);
Assert.AreEqual(strokeColor, properties.StrokeColor);
Assert.AreEqual(strokeThickness, properties.StrokeThickness);
}
