public void ChildNodeObjects_Always_ReturnsChildrenWithContextAndDataReversed()
{
// Setup
var mapPointData = new MapPointData("points");
var mapLineData = new MapLineData("lines");
var nestedCollection = new MapDataCollection("nested");
var mapPolygonData = new MapPolygonData("polygons");
var mapDataCollection = new MapDataCollection("test data");
mapDataCollection.Add(mapPointData);
mapDataCollection.Add(mapLineData);
mapDataCollection.Add(nestedCollection);
mapDataCollection.Add(mapPolygonData);
MapDataCollectionContext parentCollectionContext = GetContext(mapDataCollection);
// Call
object[] objects = info.ChildNodeObjects(GetContext(mapDataCollection));
// Assert
CollectionAssert.AreEqual(new MapDataContext[]
{
new MapPolygonDataContext(mapPolygonData, parentCollectionContext),
GetContext(nestedCollection, parentCollectionContext),
new MapLineDataContext(mapLineData, parentCollectionContext),
new MapPointDataContext(mapPointData, parentCollectionContext)
}, objects);
}
public void Features_SetInvalidValue_ThrowsArgumentException(int numberOfPointCollections)
{
// Setup
var data = new MapLineData("test data");
var invalidPointsCollections = new IEnumerable <Point2D> [numberOfPointCollections];
for (var i = 0; i < numberOfPointCollections; i++)
{
invalidPointsCollections[i] = CreateTestPoints();
}
var features = new[]
{
new MapFeature(new[]
{
new MapGeometry(invalidPointsCollections)
})
};
// Call
TestDelegate test = () => data.Features = features;
// Assert
const string expectedMessage = "MapLineData only accepts MapFeature instances whose MapGeometries contain a single point-collection.";
TestHelper.AssertThrowsArgumentExceptionAndTestMessage <ArgumentException>(test, expectedMessage);
}
public void Features_SetValidNewValue_GetsNewValue()
{
// Setup
var data = new MapLineData("test data");
var features = new[]
{
new MapFeature(Enumerable.Empty <MapGeometry>()),
new MapFeature(new[]
{
new MapGeometry(new[]
{
Enumerable.Empty <Point2D>()
}),
new MapGeometry(new[]
{
CreateTestPoints()
})
})
};
// Call
data.Features = features;
// Assert
Assert.AreSame(features, data.Features);
}
public void Constructor_WithStyleAndMapTheme_ExpectedValues()
{
// Setup
const string name = "test data";
var style = new LineStyle
{
Color = Color.Red,
Width = 5,
DashStyle = LineDashStyle.Dash
};
var mapTheme = new MapTheme <LineCategoryTheme>("attribute", new[]
{
new LineCategoryTheme(ValueCriterionTestFactory.CreateValueCriterion(),
new LineStyle())
});
// Call
var data = new MapLineData(name, style, mapTheme);
// Assert
Assert.AreEqual(name, data.Name);
CollectionAssert.IsEmpty(data.Features);
Assert.AreSame(style, data.Style);
Assert.AreSame(mapTheme, data.Theme);
}
public void FromFeatureBasedMapData_WithMapLineData_ReturnsNewRemovableDataWithSameProperties()
{
// Setup
const string name = "test";
var mapFeatures = new MapFeature[0];
var lineStyle = new LineStyle
{
Color = Color.AliceBlue,
Width = 3,
DashStyle = LineDashStyle.Dash
};
var mapData = new MapLineData(name, lineStyle)
{
Features = mapFeatures
};
// Call
var convertedData = RemovableMapDataConverter.FromFeatureBasedMapData(mapData) as RemovableMapLineData;
// Assert
Assert.NotNull(convertedData);
Assert.AreEqual(name, convertedData.Name);
Assert.AreEqual(lineStyle, convertedData.Style);
Assert.AreSame(mapFeatures, convertedData.Features);
}
/// <summary>
/// Creates a new instance of <see cref="AssemblyResultPerSectionMapView"/>.
/// </summary>
/// <param name="assessmentSection">The <see cref="AssessmentSection"/> to create the view for.</param>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="assessmentSection"/>
/// is <c>null</c>.</exception>
public AssemblyResultPerSectionMapView(AssessmentSection assessmentSection)
{
if (assessmentSection == null)
{
throw new ArgumentNullException(nameof(assessmentSection));
}
InitializeComponent();
AssessmentSection = assessmentSection;
CreateObservers();
var mapDataCollection = new MapDataCollection(Resources.AssemblyResultPerSectionMapView_DisplayName);
assemblyResultsMapData = CombinedSectionAssemblyMapDataFactory.CreateCombinedSectionAssemblyResultMapData();
referenceLineMapData = RiskeerMapDataFactory.CreateReferenceLineMapData();
hydraulicBoundaryLocationsMapLayer = new HydraulicBoundaryLocationsMapLayer(assessmentSection);
mapDataCollection.Add(referenceLineMapData);
mapDataCollection.Add(hydraulicBoundaryLocationsMapLayer.MapData);
mapDataCollection.Add(assemblyResultsMapData);
SetAllMapDataFeatures();
riskeerMapControl.SetAllData(mapDataCollection, assessmentSection.BackgroundData);
}
/// <summary>
/// Creates the map data.
/// </summary>
protected virtual void CreateMapData()
{
hydraulicBoundaryLocationsMapLayer = new HydraulicBoundaryLocationsMapLayer(AssessmentSection);
MapDataCollection = new MapDataCollection(PipingDataResources.PipingFailureMechanism_DisplayName);
referenceLineMapData = RiskeerMapDataFactory.CreateReferenceLineMapData();
stochasticSoilModelsMapData = RiskeerMapDataFactory.CreateStochasticSoilModelsMapData();
surfaceLinesMapData = RiskeerMapDataFactory.CreateSurfaceLinesMapData();
semiProbabilisticCalculationsMapData = PipingMapDataFactory.CreateSemiProbabilisticCalculationsMapData();
probabilisticCalculationsMapData = PipingMapDataFactory.CreateProbabilisticCalculationsMapData();
MapDataCollection sectionsMapDataCollection = RiskeerMapDataFactory.CreateSectionsMapDataCollection();
sectionsMapData = RiskeerMapDataFactory.CreateFailureMechanismSectionsMapData();
sectionsStartPointMapData = RiskeerMapDataFactory.CreateFailureMechanismSectionsStartPointMapData();
sectionsEndPointMapData = RiskeerMapDataFactory.CreateFailureMechanismSectionsEndPointMapData();
MapDataCollection.Add(referenceLineMapData);
MapDataCollection.Add(stochasticSoilModelsMapData);
MapDataCollection.Add(surfaceLinesMapData);
sectionsMapDataCollection.Add(sectionsMapData);
sectionsMapDataCollection.Add(sectionsStartPointMapData);
sectionsMapDataCollection.Add(sectionsEndPointMapData);
MapDataCollection.Add(sectionsMapDataCollection);
MapDataCollection.Add(hydraulicBoundaryLocationsMapLayer.MapData);
MapDataCollection.Add(probabilisticCalculationsMapData);
MapDataCollection.Add(semiProbabilisticCalculationsMapData);
}
public void CopyToFeature_FeatureContainsMultipleGeometries_ThrowsArgumentException()
{
// Setup
var feature = new MapFeature(new[]
{
new MapGeometry(new[]
{
Enumerable.Empty <Point2D>()
}),
new MapGeometry(new[]
{
Enumerable.Empty <Point2D>()
})
});
var mapData = new MapLineData("test")
{
Features = new[]
{
feature
}
};
using (var writer = new PolylineShapeFileWriter())
{
// Call
TestDelegate call = () => writer.CopyToFeature(mapData);
// Assert
TestHelper.AssertThrowsArgumentExceptionAndTestMessage <ArgumentException>(call, "Een feature mag maar één geometrie bevatten.");
}
}
public void SaveAs_ValidMapLineData_WritesShapeFile()
{
// Setup
string directoryPath = TestHelper.GetScratchPadPath(nameof(SaveAs_ValidMapLineData_WritesShapeFile));
string filePath = Path.Combine(directoryPath, "test.shp");
const string baseName = "test";
MapFeature[] features = CreateFeatures(0.0);
var mapLineData = new MapLineData("test data")
{
Features = features
};
mapLineData.Features.First().MetaData["<some key>"] = 123;
using (new DirectoryDisposeHelper(TestHelper.GetScratchPadPath(), nameof(SaveAs_ValidMapLineData_WritesShapeFile)))
using (var writer = new PolylineShapeFileWriter())
{
writer.CopyToFeature(mapLineData);
// Call
writer.SaveAs(filePath);
// Assert
string pathName = Path.Combine(directoryPath, baseName);
Assert.IsTrue(File.Exists(pathName + ".shp"));
Assert.IsTrue(File.Exists(pathName + ".shx"));
Assert.IsTrue(File.Exists(pathName + ".dbf"));
}
}
public void GetFeatureBasedMapDataRecursively_CollectionWithNestedData_ReturnAllFeatureBasedMapData()
{
// Setup
var line = new MapLineData("line");
var polygon = new MapPolygonData("polygon");
var nestedCollection = new MapDataCollection("nested");
nestedCollection.Add(line);
nestedCollection.Add(polygon);
var collection = new MapDataCollection("test");
var point = new MapPointData("point");
collection.Add(point);
collection.Add(nestedCollection);
// Call
FeatureBasedMapData[] featureBasedMapDatas = collection.GetFeatureBasedMapDataRecursively().ToArray();
// Assert
Assert.AreEqual(3, featureBasedMapDatas.Length);
Assert.IsInstanceOf <MapPointData>(featureBasedMapDatas[0]);
Assert.IsInstanceOf <MapLineData>(featureBasedMapDatas[1]);
Assert.IsInstanceOf <MapPolygonData>(featureBasedMapDatas[2]);
}
public void CopyToFeature_InconsistentMetaDataBetweenMapLineDatas_ThrowArgumentException()
{
// Setup
MapFeature[] features1 = CreateFeatures(0.0);
var mapLineData1 = new MapLineData("test data 1")
{
Features = features1
};
mapLineData1.Features.First().MetaData["firstKey"] = 123;
mapLineData1.Features.First().MetaData["secondKey"] = "aValue";
MapFeature[] features2 = CreateFeatures(10.0);
var mapLineData2 = new MapLineData("test data 2")
{
Features = features2
};
mapLineData2.Features.First().MetaData["firstKey"] = 123;
mapLineData2.Features.First().MetaData["anotherKey"] = "anotherValue";
using (var writer = new PolylineShapeFileWriter())
{
writer.CopyToFeature(mapLineData1);
// Call
TestDelegate call = () => writer.CopyToFeature(mapLineData2);
// Assert
const string message = "Column 'anotherKey' does not belong to table .";
TestHelper.AssertThrowsArgumentExceptionAndTestMessage <ArgumentException>(call, message);
}
}
/// <summary>
/// Creates a new <see cref="ReferenceLineMeta"/> from the <paramref name="lineData"/>.
/// </summary>
/// <param name="lineData">The <see cref="MapFeature"/> to create a <see cref="ReferenceLineMeta"/> from.</param>
/// <returns>The newly created <see cref="ReferenceLineMeta"/>.</returns>
private static ReferenceLineMeta CreateReferenceLineMeta(MapLineData lineData)
{
MapFeature feature = lineData.Features.First();
string assessmentSectionId = GetAssessmentSectionId(feature);
int? signalFloodingProbability = ParseNormValue(feature.MetaData[signalFloodingProbabilityValueAttributeKey]);
int? maximumAllowableFloodingProbability = ParseNormValue(feature.MetaData[maximumAllowableFloodingProbabilityValueAttributeKey]);
IEnumerable <Point2D> geometryPoints = GetSectionGeometry(feature);
var referenceLineMeta = new ReferenceLineMeta
{
AssessmentSectionId = assessmentSectionId
};
if (maximumAllowableFloodingProbability != null)
{
referenceLineMeta.MaximumAllowableFloodingProbability = maximumAllowableFloodingProbability.Value;
}
if (signalFloodingProbability != null)
{
referenceLineMeta.SignalFloodingProbability = signalFloodingProbability.Value;
}
referenceLineMeta.ReferenceLine.SetGeometry(geometryPoints);
return(referenceLineMeta);
}
public void Constructor_WithoutMapTheme_ReturnCorrectPropertyValues()
{
// Setup
Color color = Color.Aqua;
const int width = 4;
const LineDashStyle dashStyle = LineDashStyle.DashDot;
var mapLineData = new MapLineData("Test", new LineStyle
{
Color = color,
Width = width,
DashStyle = dashStyle
});
// Call
var properties = new MapLineDataProperties(mapLineData, Enumerable.Empty <MapDataCollection>());
// Assert
Assert.AreEqual("Enkel symbool", properties.StyleType);
Assert.AreEqual(mapLineData.ShowLabels, properties.ShowLabels);
Assert.IsEmpty(properties.SelectedMetaDataAttribute.MetaDataAttribute);
Assert.AreEqual(mapLineData.MetaData, properties.GetAvailableMetaDataAttributes());
Assert.AreEqual(color, properties.Color);
Assert.AreEqual(width, properties.Width);
Assert.AreEqual(dashStyle, properties.DashStyle);
CollectionAssert.IsEmpty(properties.CategoryThemes);
}
public void Constructor_MapLineDataWithMapTheme_PropertiesHaveExpectedAttributesValues()
{
// Setup
var mapLineData = new MapLineData("Test", new LineStyle(), CreateMapTheme())
{
ShowLabels = true
};
// Call
var properties = new MapLineDataProperties(mapLineData, Enumerable.Empty <MapDataCollection>());
// Assert
PropertyDescriptorCollection dynamicProperties = PropertiesTestHelper.GetAllVisiblePropertyDescriptors(properties);
Assert.AreEqual(7, dynamicProperties.Count);
const string styleCategory = "Stijl";
PropertyDescriptor categoryThemesProperty = dynamicProperties[categoryThemesPropertyIndex];
PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(categoryThemesProperty,
styleCategory,
"Categorieën",
string.Empty,
true);
}
private void CreateMapData()
{
mapDataCollection = new MapDataCollection(FailureMechanism.Name);
referenceLineMapData = RiskeerMapDataFactory.CreateReferenceLineMapData();
hydraulicBoundaryLocationsMapLayer = new HydraulicBoundaryLocationsMapLayer(AssessmentSection);
MapDataCollection sectionsMapDataCollection = RiskeerMapDataFactory.CreateSectionsMapDataCollection();
sectionsMapData = RiskeerMapDataFactory.CreateFailureMechanismSectionsMapData();
sectionsStartPointMapData = RiskeerMapDataFactory.CreateFailureMechanismSectionsStartPointMapData();
sectionsEndPointMapData = RiskeerMapDataFactory.CreateFailureMechanismSectionsEndPointMapData();
assemblyResultMapLayer = new NonCalculatableFailureMechanismSectionResultsMapLayer <TSectionResult>(
FailureMechanism, performAssemblyFunc);
mapDataCollection.Add(referenceLineMapData);
sectionsMapDataCollection.Add(sectionsMapData);
sectionsMapDataCollection.Add(sectionsStartPointMapData);
sectionsMapDataCollection.Add(sectionsEndPointMapData);
mapDataCollection.Add(sectionsMapDataCollection);
mapDataCollection.Add(assemblyResultMapLayer.MapData);
mapDataCollection.Add(hydraulicBoundaryLocationsMapLayer.MapData);
}
public void DynamicReadOnlyValidator_MapHasMetaData_ReturnsExpectedValuesForRelevantProperties(bool hasMetaData)
{
// Setup
var feature = new MapFeature(Enumerable.Empty <MapGeometry>());
if (hasMetaData)
{
feature.MetaData["key"] = "value";
}
var mapData = new MapLineData("Test")
{
Features = new[]
{
feature
}
};
var properties = new MapLineDataProperties(mapData, Enumerable.Empty <MapDataCollection>());
// Call
bool isShowLabelReadOnly = properties.DynamicReadonlyValidator(
nameof(properties.ShowLabels));
bool isSelectedMetaDataReadOnly = properties.DynamicReadonlyValidator(
nameof(properties.SelectedMetaDataAttribute));
// Assert
Assert.AreNotEqual(hasMetaData, isShowLabelReadOnly);
Assert.AreNotEqual(hasMetaData, isSelectedMetaDataReadOnly);
}
public void GivenMapLineDataPropertiesWithMapTheme_WhenCategoryThemePropertySet_ThenMapDataNotified()
{
// Given
var random = new Random(21);
var mocks = new MockRepository();
var observer = mocks.StrictMock <IObserver>();
observer.Expect(o => o.UpdateObserver());
mocks.ReplayAll();
var mapLineData = new MapLineData("Test",
new LineStyle(),
new MapTheme <LineCategoryTheme>("Attribute", new[]
{
new LineCategoryTheme(ValueCriterionTestFactory.CreateValueCriterion(), new LineStyle())
}));
mapLineData.Attach(observer);
var properties = new MapLineDataProperties(mapLineData, Enumerable.Empty <MapDataCollection>());
// When
LineCategoryThemeProperties categoryThemeProperties = properties.CategoryThemes.First();
categoryThemeProperties.Width = random.Next(1, 48);
// Then
mocks.VerifyAll();
}
public void GivenMapLineDataLayer_WhenUpdatedAfterMapLineDataFeaturesChanged_MapLineDataLayerFeaturesChanged()
{
// Given
var mapLineData = new MapLineData("Test name")
{
Features = new[]
{
CreateTestMapFeature()
}
};
var mapLineDataLayer = new MapLineDataLayer(mapLineData);
IFeature[] drawnFeatures = mapLineDataLayer.DataSet.Features.ToArray();
// When
mapLineData.Features = new[]
{
CreateTestMapFeature()
};
mapLineDataLayer.Update();
// Then
CollectionAssert.AreNotEqual(drawnFeatures, mapLineDataLayer.DataSet.Features);
}
public void DynamicVisibleValidationMethod_MapLineDataWithMapTheme_ReturnsExpectedValuesForRelevantProperties(bool hasMapTheme)
{
// Setup
MapLineData mapLineData = hasMapTheme
? new MapLineData("Test", new LineStyle(), CreateMapTheme())
: new MapLineData("Test");
var properties = new MapLineDataProperties(mapLineData, Enumerable.Empty <MapDataCollection>());
// Call
bool isCategoryThemesVisible = properties.DynamicVisibleValidationMethod(
nameof(MapLineDataProperties.CategoryThemes));
bool isLineColorStyleVisible = properties.DynamicVisibleValidationMethod(
nameof(MapLineDataProperties.Color));
bool isLineWidthVisible = properties.DynamicVisibleValidationMethod(
nameof(MapLineDataProperties.Color));
bool isLineDashStyleVisible = properties.DynamicVisibleValidationMethod(
nameof(MapLineDataProperties.Color));
// Assert
Assert.AreEqual(hasMapTheme, isCategoryThemesVisible);
Assert.AreNotEqual(hasMapTheme, isLineColorStyleVisible);
Assert.AreNotEqual(hasMapTheme, isLineWidthVisible);
Assert.AreNotEqual(hasMapTheme, isLineDashStyleVisible);
}
public void Constructor_WithMapTheme_ReturnCorrectPropertyValues()
{
// Setup
const string attributeName = "Attribute";
var categoryTheme = new LineCategoryTheme(ValueCriterionTestFactory.CreateValueCriterion(), new LineStyle());
var mapLineData = new MapLineData("Test",
new LineStyle(),
new MapTheme <LineCategoryTheme>(attributeName, new[]
{
categoryTheme
}));
// Call
var properties = new MapLineDataProperties(mapLineData, Enumerable.Empty <MapDataCollection>());
// Assert
Assert.AreEqual("Categorie", properties.StyleType);
Assert.AreEqual(mapLineData.ShowLabels, properties.ShowLabels);
Assert.IsEmpty(properties.SelectedMetaDataAttribute.MetaDataAttribute);
Assert.AreEqual(mapLineData.MetaData, properties.GetAvailableMetaDataAttributes());
Assert.AreEqual(1, properties.CategoryThemes.Length);
LineCategoryThemeProperties pointCategoryThemeProperties = properties.CategoryThemes.First();
Assert.AreSame(categoryTheme, pointCategoryThemeProperties.Data);
ValueCriterionTestHelper.AssertValueCriterionFormatExpression(attributeName,
categoryTheme.Criterion,
pointCategoryThemeProperties.Criterion);
}
private static ReferenceLine CreateReferenceLine(MapLineData lineMapData, string shapeFilePath)
{
MapFeature[] lineFeatures = lineMapData.Features.ToArray();
if (lineFeatures.Length > 1)
{
string message = new FileReaderErrorMessageBuilder(shapeFilePath)
.Build(RiskeerCommonIOResources.ReferenceLineReader_File_contains_unsupported_multi_polyline);
throw new CriticalFileReadException(message);
}
var referenceLine = new ReferenceLine();
MapFeature referenceLineFeature = lineMapData.Features.First();
MapGeometry[] referenceGeometries = referenceLineFeature.MapGeometries.ToArray();
if (referenceGeometries.Length > 1)
{
string message = new FileReaderErrorMessageBuilder(shapeFilePath)
.Build(RiskeerCommonIOResources.ReferenceLineReader_File_contains_unsupported_multi_polyline);
throw new CriticalFileReadException(message);
}
MapGeometry referenceGeometry = referenceGeometries[0];
referenceLine.SetGeometry(referenceGeometry.PointCollections.First().Select(t => new Point2D(t)).ToArray());
return(referenceLine);
}
/// <summary>
/// Reads and consumes an entry in the shapefile, using the data to create a new
/// instance of <see cref="FailureMechanismSection"/>.
/// </summary>
/// <returns>The <see cref="FailureMechanismSection"/> read from the file, or <c>null</c>
/// when at the end of the file.</returns>
/// <exception cref="CriticalFileReadException">Thrown when either:
/// <list type="bullet">
/// <item>the shapefile does not have a required attribute defined.</item>
/// <item>the element read from the file is a multi-polyline.</item>
/// </list></exception>
public FailureMechanismSection ReadFailureMechanismSection()
{
ValidateExistenceOfRequiredAttributes();
MapLineData lineData = ReadMapLineData();
return(lineData == null ? null : CreateFailureMechanismSection(lineData));
}
/// <summary>
/// Creates the map data.
/// </summary>
protected virtual void CreateMapData()
{
MapDataCollection = new MapDataCollection(DuneErosionDataResources.DuneErosionFailureMechanism_DisplayName);
referenceLineMapData = RiskeerMapDataFactory.CreateReferenceLineMapData();
duneErosionLocationsMapLayer = new DuneErosionLocationsMapLayer(FailureMechanism);
MapDataCollection.Add(referenceLineMapData);
MapDataCollection.Add(duneErosionLocationsMapLayer.MapData);
}
public void CreateCalculationsMapData_WithoutParameters_ReturnsEmptyMapPointDataWithExpectedStyling()
{
// Call
MapLineData data = RiskeerMapDataFactory.CreateCalculationsMapData();
// Assert
CollectionAssert.IsEmpty(data.Features);
Assert.AreEqual("Berekeningen", data.Name);
RiskeerMapDataFactoryTestHelper.AssertEqualStyle(data.Style, Color.MediumPurple, 2, LineDashStyle.Dash);
}
public void CreateProbabilisticCalculationsMapData_ReturnsEmptyMapPointDataWithExpectedStyling()
{
// Call
MapLineData data = PipingMapDataFactory.CreateProbabilisticCalculationsMapData();
// Assert
CollectionAssert.IsEmpty(data.Features);
Assert.AreEqual("Probabilistische berekeningen", data.Name);
RiskeerMapDataFactoryTestHelper.AssertEqualStyle(data.Style, Color.Pink, 2, LineDashStyle.Dash);
}
public void CreateStochasticSoilModelsMapData_ReturnsEmptyMapLineDataWithExpectedStyling()
{
// Call
MapLineData data = RiskeerMapDataFactory.CreateStochasticSoilModelsMapData();
// Assert
CollectionAssert.IsEmpty(data.Features);
Assert.AreEqual("Stochastische ondergrondmodellen", data.Name);
RiskeerMapDataFactoryTestHelper.AssertEqualStyle(data.Style, Color.FromArgb(70, Color.SaddleBrown), 5, LineDashStyle.Solid);
Assert.AreEqual("Naam", data.SelectedMetaDataAttribute);
}
public void CreateSurfaceLinesMapData_ReturnsEmptyMapLineDataWithExpectedStyling()
{
// Call
MapLineData data = RiskeerMapDataFactory.CreateSurfaceLinesMapData();
// Assert
CollectionAssert.IsEmpty(data.Features);
Assert.AreEqual("Profielschematisaties", data.Name);
RiskeerMapDataFactoryTestHelper.AssertEqualStyle(data.Style, Color.DarkSeaGreen, 2, LineDashStyle.Solid);
Assert.AreEqual("Naam", data.SelectedMetaDataAttribute);
}
public void CreateFailureMechanismSectionsMapData_ReturnsEmptyMapLineDataWithExpectedStyling()
{
// Call
MapLineData data = RiskeerMapDataFactory.CreateFailureMechanismSectionsMapData();
// Assert
CollectionAssert.IsEmpty(data.Features);
Assert.AreEqual("Vakindeling", data.Name);
RiskeerMapDataFactoryTestHelper.AssertEqualStyle(data.Style, Color.Khaki, 3, LineDashStyle.Dot);
Assert.AreEqual("Naam", data.SelectedMetaDataAttribute);
}
public void CreateReferenceLineMapData_ReturnsEmptyMapLineDataWithExpectedStyling()
{
// Call
MapLineData data = RiskeerMapDataFactory.CreateReferenceLineMapData();
// Assert
CollectionAssert.IsEmpty(data.Features);
Assert.AreEqual("Referentielijn", data.Name);
RiskeerMapDataFactoryTestHelper.AssertEqualStyle(data.Style, Color.FromArgb(0, 128, 255), 3, LineDashStyle.Solid);
Assert.AreEqual("Naam", data.SelectedMetaDataAttribute);
}
public void CreateDikeProfileMapData_ReturnsEmptyMapLineDataWithExpectedStyling()
{
// Call
MapLineData data = RiskeerMapDataFactory.CreateDikeProfileMapData();
// Assert
CollectionAssert.IsEmpty(data.Features);
Assert.AreEqual("Dijkprofielen", data.Name);
RiskeerMapDataFactoryTestHelper.AssertEqualStyle(data.Style, Color.SaddleBrown, 2, LineDashStyle.Solid);
Assert.AreEqual("Naam", data.SelectedMetaDataAttribute);
}
