/// <summary> /// Asserts whether the <paramref name="actualExpression"/> matches with /// the expected expression based on the <paramref name="expectedAttributeName"/> /// and <paramref name="valueCriterion"/>. /// </summary> /// <param name="expectedAttributeName">The expected attribute name.</param> /// <param name="valueCriterion">The <see cref="ValueCriterion"/> the expression /// is based on.</param> /// <param name="actualExpression">The actual expression to assert.</param> /// <exception cref="NotSupportedException">Thrown when <see cref="ValueCriterion"/> /// contains an invalid value for the criterion operator.</exception> /// <exception cref="AssertionException">Thrown when <paramref name="actualExpression"/> /// does not match with the expected expression.</exception> public static void AssertValueCriterionFormatExpression(string expectedAttributeName, ValueCriterion valueCriterion, string actualExpression) { string expectedExpression = GetExpectedFormatExpression(valueCriterion, expectedAttributeName); Assert.AreEqual(expectedExpression, actualExpression); }
public void Constructor_WithValidArguments_ExpectedValues() { // Setup ValueCriterion criterion = ValueCriterionTestFactory.CreateValueCriterion(); // Call var category = new TestCategoryTheme(criterion); // Assert Assert.AreSame(criterion, category.Criterion); }
public void Constructor_ReturnsExpectedProperties(string value) { // Setup var random = new Random(21); var valueOperator = random.NextEnumValue <ValueCriterionOperator>(); // Call var criteria = new ValueCriterion(valueOperator, value); // Assert Assert.AreEqual(valueOperator, criteria.ValueOperator); Assert.AreEqual(value, criteria.Value); }
public void ConvertLayerProperties_MapDataWithMapThemeAndVaryingValueCriteria_SetsCorrectFilterExpression(ValueCriterionOperator criterionOperator, string expressionFormat) { // Setup const string metadataAttributeName = "Meta"; const string value = "test value"; var valueCriterion = new ValueCriterion(criterionOperator, value); var theme = new MapTheme <TestCategoryTheme>(metadataAttributeName, new[] { new TestCategoryTheme(valueCriterion) }); var mapData = new TestFeatureBasedMapData("test data", theme) { Features = new[] { new MapFeature(Enumerable.Empty <MapGeometry>()) { MetaData = { { metadataAttributeName, new object() } } } } }; var featureScheme = new PointScheme(); var defaultCategory = new PointCategory(); var category = new PointCategory(); var testConverter = new TestFeatureBasedMapDataConverter { CreatedFeatureScheme = featureScheme, CreatedDefaultCategory = defaultCategory, CreatedCategoryThemeCategory = category }; var mapLayer = new TestFeatureLayer(); // Call testConverter.ConvertLayerProperties(mapData, mapLayer); // Assert Assert.IsNull(defaultCategory.FilterExpression); string expectedFilterExpression = string.Format(expressionFormat, value); Assert.AreEqual(expectedFilterExpression, category.FilterExpression); }
public void Constructor_ExpectedValues() { // Setup ValueCriterion valueCriterion = ValueCriterionTestFactory.CreateValueCriterion(); var style = new PointStyle(); // Call var category = new PointCategoryTheme(valueCriterion, style); // Assert Assert.IsInstanceOf <CategoryTheme>(category); Assert.AreSame(valueCriterion, category.Criterion); Assert.AreSame(style, category.Style); }
/// <summary> /// Creates a filter expression based for an attribute and the criteria to apply. /// </summary> /// <param name="attributeIndex">The index of the attribute in the metadata table.</param> /// <param name="criterion">The criterion to convert to an expression.</param> /// <returns>The filter expression based on the <paramref name="attributeIndex"/> /// and <paramref name="criterion"/>.</returns> /// <exception cref="NotSupportedException">Thrown when the <paramref name="criterion"/> /// cannot be used to create a filter expression.</exception> private static string CreateFilterExpression(int attributeIndex, ValueCriterion criterion) { ValueCriterionOperator valueOperator = criterion.ValueOperator; switch (valueOperator) { case ValueCriterionOperator.EqualValue: return($"[{attributeIndex}] = '{criterion.Value}'"); case ValueCriterionOperator.UnequalValue: return($"NOT [{attributeIndex}] = '{criterion.Value}'"); default: throw new NotSupportedException(); } }
private static string GetExpectedFormatExpression(ValueCriterion valueCriterion, string attributeName) { string valueCriterionValue = valueCriterion.Value; switch (valueCriterion.ValueOperator) { case ValueCriterionOperator.EqualValue: return($"{attributeName} = {valueCriterionValue}"); case ValueCriterionOperator.UnequalValue: return($"{attributeName} ≠ {valueCriterionValue}"); default: throw new NotSupportedException(); } }
public void Constructor_Always_ReturnExpectedValues(ValueCriterionOperator valueOperator, string formatExpression) { // Setup const string attributeName = "AttributeName"; const string value = "random value 123"; var criterion = new ValueCriterion(valueOperator, value); var theme = new TestCategoryTheme(criterion); // Call var properties = new TestCategoryThemeProperties(attributeName, theme, new TestFeatureBasedMapData()); // Assert string expectedValue = string.Format(formatExpression, attributeName, value); Assert.AreEqual(expectedValue, properties.Criterion); }
public void Constructor_Always_ReturnExpectedPropertyValues() { // Setup const string attributeName = "AttributeName"; ValueCriterion valueCriterion = ValueCriterionTestFactory.CreateValueCriterion(); var categoryTheme = new LineCategoryTheme(valueCriterion, new LineStyle()); var properties = new LineCategoryThemeProperties(categoryTheme, attributeName, new MapLineData("Name")); // Assert Assert.AreSame(categoryTheme, properties.Data); Assert.AreEqual(categoryTheme.Style.Color, properties.Color); Assert.AreEqual(categoryTheme.Style.Width, properties.Width); Assert.AreEqual(categoryTheme.Style.DashStyle, properties.DashStyle); ValueCriterionTestHelper.AssertValueCriterionFormatExpression(attributeName, valueCriterion, properties.Criterion); }
public void Constructor_Always_ReturnExpectedPropertyValues() { // Setup const string attributeName = "AttributeName"; ValueCriterion valueCriterion = ValueCriterionTestFactory.CreateValueCriterion(); var categoryTheme = new PolygonCategoryTheme(valueCriterion, new PolygonStyle()); var properties = new PolygonCategoryThemeProperties(categoryTheme, attributeName, new MapPolygonData("Name")); // Assert Assert.AreSame(categoryTheme, properties.Data); Assert.AreEqual(categoryTheme.Style.FillColor, properties.FillColor); Assert.AreEqual(categoryTheme.Style.StrokeColor, properties.StrokeColor); Assert.AreEqual(categoryTheme.Style.StrokeThickness, properties.StrokeThickness); ValueCriterionTestHelper.AssertValueCriterionFormatExpression(attributeName, valueCriterion, properties.Criterion); }
public TestCategoryTheme(ValueCriterion criterion) : base(criterion) { }
public void ConvertLayerProperties_MapPolygonDataWithThemeAndMetaDataNameInFeatures_ConvertDataToMapPolygonLayer() { // Setup const string metadataAttribute = "Meta"; var random = new Random(21); var unequalCriterion = new ValueCriterion(ValueCriterionOperator.UnequalValue, "unequal value"); var equalCriterion = new ValueCriterion(ValueCriterionOperator.EqualValue, "equal value"); var theme = new MapTheme <PolygonCategoryTheme>(metadataAttribute, new[] { new PolygonCategoryTheme(equalCriterion, new PolygonStyle { FillColor = Color.FromKnownColor(random.NextEnum <KnownColor>()), StrokeColor = Color.FromKnownColor(random.NextEnum <KnownColor>()), StrokeThickness = random.Next(1, 48) }), new PolygonCategoryTheme(unequalCriterion, new PolygonStyle { FillColor = Color.FromKnownColor(random.NextEnum <KnownColor>()), StrokeColor = Color.FromKnownColor(random.NextEnum <KnownColor>()), StrokeThickness = random.Next(1, 48) }) }); var polygonStyle = new PolygonStyle { FillColor = Color.FromKnownColor(random.NextEnum <KnownColor>()), StrokeColor = Color.FromKnownColor(random.NextEnum <KnownColor>()), StrokeThickness = random.Next(1, 48) }; var mapPolygonData = new MapPolygonData("test", polygonStyle, theme) { Features = new[] { CreateMapFeatureWithMetaData(metadataAttribute) } }; var mapPolygonLayer = new MapPolygonLayer(); var converter = new MapPolygonDataConverter(); // Call converter.ConvertLayerProperties(mapPolygonData, mapPolygonLayer); // Assert PolygonSymbolizer expectedSymbolizer = CreateExpectedSymbolizer(polygonStyle); IPolygonScheme appliedScheme = mapPolygonLayer.Symbology; Assert.AreEqual(3, appliedScheme.Categories.Count); IPolygonCategory baseCategory = appliedScheme.Categories[0]; AssertAreEqual(expectedSymbolizer, baseCategory.Symbolizer); Assert.IsNull(baseCategory.FilterExpression); IPolygonCategory equalSchemeCategory = appliedScheme.Categories[1]; string expectedFilter = $"[1] = '{equalCriterion.Value}'"; Assert.AreEqual(expectedFilter, equalSchemeCategory.FilterExpression); PolygonStyle expectedCategoryStyle = theme.CategoryThemes.ElementAt(0).Style; expectedSymbolizer = CreateExpectedSymbolizer(expectedCategoryStyle); AssertAreEqual(expectedSymbolizer, equalSchemeCategory.Symbolizer); IPolygonCategory unEqualSchemeCategory = appliedScheme.Categories[2]; expectedFilter = $"NOT [1] = '{unequalCriterion.Value}'"; Assert.AreEqual(expectedFilter, unEqualSchemeCategory.FilterExpression); expectedCategoryStyle = theme.CategoryThemes.ElementAt(1).Style; expectedSymbolizer = CreateExpectedSymbolizer(expectedCategoryStyle); AssertAreEqual(expectedSymbolizer, unEqualSchemeCategory.Symbolizer); }