public void AddRow_ValidDataWithColor_AddRowToCollection()
{
// Setup
const string name = "Row 1";
var values = new[]
{
1.2
};
Color color = Color.Yellow;
var data = new StackChartData();
data.AddColumn("Column 1");
// Call
data.AddRow(name, values, color);
// Assert
Assert.AreEqual(1, data.Rows.Count());
RowChartData row = data.Rows.First();
Assert.AreEqual(name, row.Name);
CollectionAssert.AreEqual(values, row.Values);
Assert.AreEqual(color, row.Color);
}
public void GivenChartControlWithoutData_WhenDataSetToStackChartData_ThenChartControlUpdated()
{
// Given
using (var chart = new StackChartControl())
{
var data = new StackChartData();
data.AddColumn("Column 1");
data.AddColumn("Column 2");
data.AddRow("Row 1", new[]
{
0.4,
0.2
});
data.AddRow("Row 2", new[]
{
0.6,
0.8
});
// When
chart.Data = data;
// Then
CategoryPlotView plotView = chart.Controls.OfType <CategoryPlotView>().Single();
AssertColumns(data.Columns.ToList(), plotView);
AssertSeries(data.Rows.Select(r => r.Name).ToList(), plotView);
}
}
/// <summary>
/// Creates a new instance of <see cref="IllustrationPointsChartControl"/>.
/// </summary>
public IllustrationPointsChartControl()
{
InitializeComponent();
chartData = RiskeerStackChartDataFactory.Create();
stackChartControl.Data = chartData;
}
/// <summary>
/// Creates the columns for the given <paramref name="stackChartData"/>.
/// </summary>
/// <param name="illustrationPointControlItems">The data to create the columns from.</param>
/// <param name="stackChartData">The stack chart data to create the columns for.</param>
/// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
public static void CreateColumns(IEnumerable <IllustrationPointControlItem> illustrationPointControlItems,
StackChartData stackChartData)
{
if (illustrationPointControlItems == null)
{
throw new ArgumentNullException(nameof(illustrationPointControlItems));
}
if (stackChartData == null)
{
throw new ArgumentNullException(nameof(stackChartData));
}
IEnumerable <Tuple <string, string> > labels =
illustrationPointControlItems.Select(controlItem => Tuple.Create(controlItem.WindDirectionName,
controlItem.ClosingSituation)).ToArray();
bool showClosingSituation = illustrationPointControlItems.HasMultipleUniqueValues(item => item.ClosingSituation);
foreach (Tuple <string, string> label in labels)
{
string columnName = label.Item1;
if (showClosingSituation)
{
columnName = string.Format(Resources.RiskeerStackChartDataFactory_CreateColumns_WindDirection_0_ClosingSituation_1,
columnName,
label.Item2);
}
stackChartData.AddColumn(columnName);
}
}
private static void CreateRowsForStochasts(StackChartData stackChartData, IDictionary <string, List <RoundedDouble> > stochasts)
{
IDictionary <string, List <RoundedDouble> > significantStochasts = new Dictionary <string, List <RoundedDouble> >();
IDictionary <string, List <RoundedDouble> > remainingStochasts = new Dictionary <string, List <RoundedDouble> >();
foreach (KeyValuePair <string, List <RoundedDouble> > stochast in stochasts)
{
if (StochastIsSignificant(stochast))
{
significantStochasts.Add(stochast);
}
else
{
remainingStochasts.Add(stochast);
}
}
foreach (KeyValuePair <string, List <RoundedDouble> > significantStochast in significantStochasts)
{
stackChartData.AddRow(significantStochast.Key, significantStochast.Value.Select(v => v.Value).ToArray());
}
if (remainingStochasts.Any())
{
stackChartData.AddRow(Resources.RiskeerStackChartDataFactory_RemainingRow_DisplayName,
GetValuesForRemainingRow(remainingStochasts),
Color.Gray);
}
}
public void GivenChartControlWithData_WhenDataSetToOtherStackChartData_ThenChartControlUpdated()
{
// Given
using (var chart = new StackChartControl())
{
var data = new StackChartData();
data.AddColumn("Column 1");
data.AddColumn("Column 2");
data.AddRow("Row 1", new[]
{
0.4,
0.2
});
data.AddRow("Row 2", new[]
{
0.6,
0.8
});
chart.Data = data;
// Precondition
CategoryPlotView plotView = chart.Controls.OfType <CategoryPlotView>().Single();
AssertColumns(data.Columns.ToList(), plotView);
AssertSeries(data.Rows.Select(r => r.Name).ToList(), plotView);
// When
var newData = new StackChartData();
newData.AddColumn("Column 3");
newData.AddColumn("Column 4");
newData.AddRow("Row 3", new[]
{
0.5,
0.7
});
newData.AddRow("Row 4", new[]
{
0.5,
0.3
});
chart.Data = newData;
// Then
ElementCollection <Series> series = plotView.Model.Series;
Assert.AreEqual(2, series.Count);
Assert.AreEqual("Row 3", series[0].Title);
Assert.AreEqual("Row 4", series[1].Title);
CategoryAxis axis = plotView.Model.Axes.OfType <CategoryAxis>().Single();
Assert.AreEqual(2, axis.Labels.Count);
Assert.AreEqual("Column 3", axis.Labels[0]);
Assert.AreEqual("Column 4", axis.Labels[1]);
AssertColumns(newData.Columns.ToList(), plotView);
AssertSeries(newData.Rows.Select(r => r.Name).ToList(), plotView);
}
}
/// <summary>
/// Creates a <see cref="RowChartDataSeries"/> based on <paramref name="data"/>.
/// </summary>
/// <param name="data">The <see cref="StackChartData"/> to create <see cref="RowChartDataSeries"/> from.</param>
/// <returns>An <see cref="IEnumerable{T}"/> of <see cref="RowChartDataSeries"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="data"/> is <c>null</c>.</exception>
public static IEnumerable <RowChartDataSeries> Create(StackChartData data)
{
if (data == null)
{
throw new ArgumentNullException(nameof(data));
}
return(data.Rows.Select(row => new RowChartDataSeries(row)));
}
public void Create_Always_ReturnStackChartData()
{
// Call
StackChartData stackChartData = RiskeerStackChartDataFactory.Create();
// Assert
CollectionAssert.IsEmpty(stackChartData.Columns);
CollectionAssert.IsEmpty(stackChartData.Rows);
}
public void Constructor_ExpectedValues()
{
// Call
var data = new StackChartData();
// Assert
Assert.IsInstanceOf <Observable>(data);
CollectionAssert.IsEmpty(data.Columns);
CollectionAssert.IsEmpty(data.Rows);
}
public void GivenChartControlWithData_WhenDataNotified_ThenChartControlUpdated()
{
// Given
using (var chart = new StackChartControl())
{
var data = new StackChartData();
data.AddColumn("Column 1");
data.AddColumn("Column 2");
data.AddRow("Row 1", new[]
{
0.4,
0.2
});
data.AddRow("Row 2", new[]
{
0.6,
0.8
});
chart.Data = data;
CategoryPlotView plotView = chart.Controls.OfType <CategoryPlotView>().Single();
AssertColumns(data.Columns.ToList(), plotView);
AssertSeries(data.Rows.Select(r => r.Name).ToList(), plotView);
// When
data.Clear();
data.AddColumn("New column 1");
data.AddColumn("New column 2");
data.AddRow("New row 1", new[]
{
0.3,
0.8
});
data.AddRow("New row 2", new[]
{
0.8,
0.2
});
data.NotifyObservers();
// Then
ElementCollection <Series> series = plotView.Model.Series;
Assert.AreEqual(2, series.Count);
Assert.AreEqual("New row 1", series[0].Title);
Assert.AreEqual("New row 2", series[1].Title);
CategoryAxis axis = plotView.Model.Axes.OfType <CategoryAxis>().Single();
Assert.AreEqual(2, axis.Labels.Count);
Assert.AreEqual("New column 1", axis.Labels[0]);
Assert.AreEqual("New column 2", axis.Labels[1]);
}
}
public void AddColumn_NameNull_ThrowsArgumentNullException()
{
// Setup
var data = new StackChartData();
// Call
TestDelegate test = () => data.AddColumn(null);
// Assert
var exception = Assert.Throws <ArgumentNullException>(test);
Assert.AreEqual("name", exception.ParamName);
}
public void AddColumn_WithName_AddColumnToCollection()
{
// Setup
const string columnName = "Column 1";
var data = new StackChartData();
// Call
data.AddColumn(columnName);
// Assert
Assert.AreEqual(1, data.Columns.Count());
string column = data.Columns.First();
Assert.AreEqual(columnName, column);
}
public void AddRow_ValuesNull_ThrowsArgumentNullException()
{
// Setup
var data = new StackChartData();
data.AddColumn("Column 1");
// Call
TestDelegate test = () => data.AddRow("test", null, Color.White);
// Assert
var exception = Assert.Throws <ArgumentNullException>(test);
Assert.AreEqual("values", exception.ParamName);
}
public void AddRow_NoColumnsAdded_ThrowInvalidOperationException()
{
// Setup
var data = new StackChartData();
// Call
TestDelegate test = () => data.AddRow("Row", new[]
{
1.1,
2.2
});
// Assert
var exception = Assert.Throws <InvalidOperationException>(test);
Assert.AreEqual("Cannot add rows before columns are added.", exception.Message);
}
public void AddColumn_RowsAdded_ThrowsInvalidOperationException()
{
// Setup
var data = new StackChartData();
data.AddColumn("Column 1");
data.AddRow("Row 1", new[]
{
1.1
});
// Call
TestDelegate test = () => data.AddColumn("Column 2");
// Assert
var exception = Assert.Throws <InvalidOperationException>(test);
Assert.AreEqual("Cannot add columns when rows already present.", exception.Message);
}
public void Create_CompleteStackChartData_ReturnChartDataSeriesForRows()
{
// Setup
var data = new StackChartData();
data.AddColumn("Column 1");
data.AddColumn("Column 2");
data.AddRow("Row 1", new[]
{
0.1,
0.9
});
// Call
IEnumerable <RowChartDataSeries> series = RowChartDataSeriesFactory.Create(data);
// Assert
Assert.AreEqual(data.Rows.Count(), series.Count());
}
public void AddRow_NumberOfColumnsDifferentThanValueItems_ThrowsArgumentException()
{
// Setup
var data = new StackChartData();
data.AddColumn("column 1");
data.AddColumn("column 2");
// Call
TestDelegate test = () => data.AddRow("test", new[]
{
2.1
});
// Assert
const string message = "The number of value items must be the same as the number of columns.";
var exception = TestHelper.AssertThrowsArgumentExceptionAndTestMessage <ArgumentException>(test, message);
Assert.AreEqual("values", exception.ParamName);
}
public void GivenChartControlWithData_WhenDataSetToNull_ThenChartControlUpdated()
{
// Given
using (var chart = new StackChartControl())
{
var data = new StackChartData();
data.AddColumn("Column 1");
data.AddColumn("Column 2");
data.AddRow("Row 1", new[]
{
0.4,
0.2
});
data.AddRow("Row 2", new[]
{
0.6,
0.8
});
chart.Data = data;
// Precondition
CategoryPlotView plotView = chart.Controls.OfType <CategoryPlotView>().Single();
AssertColumns(data.Columns.ToList(), plotView);
AssertSeries(data.Rows.Select(r => r.Name).ToList(), plotView);
// When
chart.Data = null;
// Then
ElementCollection <Series> series = plotView.Model.Series;
CollectionAssert.IsEmpty(series);
CategoryAxis axis = plotView.Model.Axes.OfType <CategoryAxis>().Single();
CollectionAssert.IsEmpty(axis.Labels);
}
}
public void CreateColumns_DifferentClosingSituations_ColumnsAddedToStackChartData()
{
// Setup
const string closingSituationRegular = "Regular";
const string closingSituationClosed = "Closed";
var beta = (RoundedDouble)3.14;
var stackChartData = new StackChartData();
var controlItems = new[]
{
new IllustrationPointControlItem(new TestTopLevelIllustrationPoint(),
"WindDirection 1",
closingSituationRegular,
Enumerable.Empty <Stochast>(),
beta),
new IllustrationPointControlItem(new TestTopLevelIllustrationPoint(),
"WindDirection 2",
closingSituationClosed,
Enumerable.Empty <Stochast>(),
beta),
new IllustrationPointControlItem(new TestTopLevelIllustrationPoint(),
"WindDirection 3",
closingSituationClosed,
Enumerable.Empty <Stochast>(),
beta)
};
// Call
RiskeerStackChartDataFactory.CreateColumns(controlItems, stackChartData);
// Assert
string[] columns = stackChartData.Columns.ToArray();
Assert.AreEqual(3, columns.Length);
Assert.AreEqual($"{controlItems[0].WindDirectionName} ({closingSituationRegular})", columns[0]);
Assert.AreEqual($"{controlItems[1].WindDirectionName} ({closingSituationClosed})", columns[1]);
Assert.AreEqual($"{controlItems[2].WindDirectionName} ({closingSituationClosed})", columns[2]);
}
public void Clear_Always_ClearsAllColumnsAndRows()
{
// Setup
var data = new StackChartData();
data.AddColumn("Column 1");
data.AddColumn("Column 2");
data.AddRow("Row 1", new[]
{
1.0,
2.0
});
// Precondition
Assert.AreEqual(2, data.Columns.Count());
Assert.AreEqual(1, data.Rows.Count());
// Call
data.Clear();
// Assert
CollectionAssert.IsEmpty(data.Columns);
CollectionAssert.IsEmpty(data.Rows);
}
public void CreateColumns_SingleClosingSituationSingleIllustrationPoint_ColumnsAddedToStackChartData()
{
// Setup
var stackChartData = new StackChartData();
const string closingSituation = "Regular";
var beta = (RoundedDouble)3.14;
var controlItems = new[]
{
new IllustrationPointControlItem(new TestTopLevelIllustrationPoint(),
"WindDirectionName1",
closingSituation,
Enumerable.Empty <Stochast>(),
beta)
};
// Call
RiskeerStackChartDataFactory.CreateColumns(controlItems, stackChartData);
// Assert
string[] columns = stackChartData.Columns.ToArray();
Assert.AreEqual(1, columns.Length);
Assert.AreEqual(controlItems[0].WindDirectionName, columns[0]);
}
/// <summary>
/// Creates the rows for the given <paramref name="stackChartData"/>.
/// </summary>
/// <param name="illustrationPointControlItems">The data to create the rows from.</param>
/// <param name="stackChartData">The stack chart data to create the rows for.</param>
/// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
public static void CreateRows(IEnumerable <IllustrationPointControlItem> illustrationPointControlItems, StackChartData stackChartData)
{
if (illustrationPointControlItems == null)
{
throw new ArgumentNullException(nameof(illustrationPointControlItems));
}
if (stackChartData == null)
{
throw new ArgumentNullException(nameof(stackChartData));
}
var stochastValues = new List <Tuple <string, RoundedDouble> >();
foreach (IllustrationPointControlItem illustrationPointControlItem in illustrationPointControlItems)
{
stochastValues.AddRange(GetStochastValues(illustrationPointControlItem));
}
IDictionary <string, List <RoundedDouble> > stochasts = CreateStochastsLookup(stochastValues);
CreateRowsForStochasts(stackChartData, stochasts);
}
public void CreateRows_WithAllData_RowsAddedToStackChartData()
{
var stackChartData = new StackChartData();
const string windDirectionName = "SSE";
const string closingSituation = "Regular";
var beta = (RoundedDouble)3.14;
var controlItems = new[]
{
new IllustrationPointControlItem(new TestTopLevelIllustrationPoint(),
windDirectionName,
closingSituation,
new[]
{
new TestSubMechanismIllustrationPointStochast("Stochast 1", -0.9),
new TestSubMechanismIllustrationPointStochast("Stochast 2", -0.43589),
new TestSubMechanismIllustrationPointStochast("Stochast 3", -0.01),
new TestSubMechanismIllustrationPointStochast("Stochast 4", -0.01),
new TestSubMechanismIllustrationPointStochast("Stochast 5", -0.099)
}, beta),
new IllustrationPointControlItem(new TestTopLevelIllustrationPoint(),
windDirectionName,
closingSituation,
new[]
{
new TestSubMechanismIllustrationPointStochast("Stochast 1", -0.43589),
new TestSubMechanismIllustrationPointStochast("Stochast 2", -0.9),
new TestSubMechanismIllustrationPointStochast("Stochast 3", -0.02),
new TestSubMechanismIllustrationPointStochast("Stochast 4", -0.02),
new TestSubMechanismIllustrationPointStochast("Stochast 5", -0.9)
}, beta),
new IllustrationPointControlItem(new TestTopLevelIllustrationPoint(),
windDirectionName,
closingSituation,
new[]
{
new TestSubMechanismIllustrationPointStochast("Stochast 1", -0.43589),
new TestSubMechanismIllustrationPointStochast("Stochast 2", -0.9),
new TestSubMechanismIllustrationPointStochast("Stochast 3", -0.03),
new TestSubMechanismIllustrationPointStochast("Stochast 4", -0.03),
new TestSubMechanismIllustrationPointStochast("Stochast 5", -0.099)
}, beta)
};
RiskeerStackChartDataFactory.CreateColumns(controlItems, stackChartData);
// Call
RiskeerStackChartDataFactory.CreateRows(controlItems, stackChartData);
// Assert
RowChartData[] rows = stackChartData.Rows.ToArray();
Assert.AreEqual(4, rows.Length);
Assert.AreEqual("Stochast 1", rows[0].Name);
CollectionAssert.AreEqual(new[]
{
0.81,
0.19,
0.19
}, rows[0].Values, new DoubleWithToleranceComparer(1e-6));
Assert.IsNull(rows[0].Color);
Assert.AreEqual("Stochast 2", rows[1].Name);
CollectionAssert.AreEqual(new[]
{
0.19,
0.81,
0.81
}, rows[1].Values, new DoubleWithToleranceComparer(1e-6));
Assert.IsNull(rows[1].Color);
Assert.AreEqual("Stochast 5", rows[2].Name);
CollectionAssert.AreEqual(new[]
{
0.00980,
0.81,
0.00980
}, rows[2].Values, new DoubleWithToleranceComparer(1e-6));
Assert.IsNull(rows[2].Color);
Assert.AreEqual("Overig", rows[3].Name);
CollectionAssert.AreEqual(new[]
{
0.0002,
0.0008,
0.0018
}, rows[3].Values, new DoubleWithToleranceComparer(1e-6));
Assert.AreEqual(Color.Gray, rows[3].Color);
}
