/// <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);
}
