private static void AssertCombinedFailureMechanismSectionAssemblyResultMapData(IEnumerable <CombinedFailureMechanismSectionAssemblyResult> expectedAssemblyResults,
ReferenceLine referenceLine,
MapData mapData)
{
Assert.IsInstanceOf <MapLineData>(mapData);
var assemblyResultMapData = (MapLineData)mapData;
int expectedNrOfResults = expectedAssemblyResults.Count();
IEnumerable <MapFeature> mapFeatures = assemblyResultMapData.Features;
Assert.AreEqual(expectedNrOfResults, mapFeatures.Count());
for (var i = 0; i < expectedNrOfResults; i++)
{
CombinedFailureMechanismSectionAssemblyResult expectedAssemblyResult = expectedAssemblyResults.ElementAt(i);
MapFeature actualFeature = mapFeatures.ElementAt(i);
MapGeometry mapGeometry = actualFeature.MapGeometries.Single();
AssertEqualPointCollections(referenceLine,
expectedAssemblyResult,
mapGeometry);
Assert.AreEqual(1, actualFeature.MetaData.Keys.Count);
Assert.AreEqual(EnumDisplayNameHelper.GetDisplayName(expectedAssemblyResult.TotalResult),
mapFeatures.ElementAt(i).MetaData["Duidingsklasse"]);
}
}
/// <summary>
/// Creates features for the combined failure mechanism section assembly.
/// </summary>
/// <param name="assessmentSection">The <see cref="AssessmentSection"/> to create the features for.</param>
/// <returns>A collection of <see cref="MapFeature"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="assessmentSection"/>
/// is <c>null</c>.</exception>
public static IEnumerable<MapFeature> CreateCombinedFailureMechanismSectionAssemblyFeatures(AssessmentSection assessmentSection)
{
if (assessmentSection == null)
{
throw new ArgumentNullException(nameof(assessmentSection));
}
IEnumerable<CombinedFailureMechanismSectionAssemblyResult> assemblyResults;
try
{
assemblyResults = AssessmentSectionAssemblyFactory.AssembleCombinedPerFailureMechanismSection(assessmentSection);
}
catch (AssemblyException)
{
return Array.Empty<MapFeature>();
}
var mapFeatures = new List<MapFeature>();
foreach (CombinedFailureMechanismSectionAssemblyResult assemblyResult in assemblyResults)
{
IEnumerable<Point2D> geometry = FailureMechanismSectionHelper.GetFailureMechanismSectionGeometry(
assessmentSection.ReferenceLine, assemblyResult.SectionStart, assemblyResult.SectionEnd);
MapFeature mapFeature = RiskeerMapDataFeaturesFactory.CreateSingleLineMapFeature(geometry);
mapFeature.MetaData[RiskeerCommonFormsResources.AssemblyGroup_DisplayName] =
EnumDisplayNameHelper.GetDisplayName(assemblyResult.TotalResult);
mapFeatures.Add(mapFeature);
}
return mapFeatures;
}
public void Constructor_PerformAssemblyFuncReturnsResult_ReturnsAssemblyResult()
{
// Setup
var mocks = new MockRepository();
var errorProvider = mocks.Stub <IFailureMechanismSectionResultRowErrorProvider>();
mocks.ReplayAll();
FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
var result = new NonAdoptableWithProfileProbabilityFailureMechanismSectionResult(section);
FailureMechanismSectionAssemblyResultWrapper assemblyResultWrapper = FailureMechanismSectionAssemblyResultWrapperTestFactory.Create();
Func <FailureMechanismSectionAssemblyResultWrapper> performAssemblyFunc = () => assemblyResultWrapper;
// Call
var row = new NonAdoptableWithProfileProbabilityFailureMechanismSectionResultRow(result, errorProvider, performAssemblyFunc, ConstructionProperties);
// Assert
FailureMechanismSectionAssemblyResult assemblyResult = assemblyResultWrapper.AssemblyResult;
Assert.AreEqual(assemblyResult.ProfileProbability, row.ProfileProbability);
Assert.AreEqual(assemblyResult.SectionProbability, row.SectionProbability);
Assert.AreEqual(assemblyResult.N, row.SectionN, row.SectionN.GetAccuracy());
Assert.AreEqual(2, row.SectionN.NumberOfDecimalPlaces);
Assert.AreEqual(EnumDisplayNameHelper.GetDisplayName(assemblyResult.FailureMechanismSectionAssemblyGroup),
row.AssemblyGroup);
mocks.VerifyAll();
}
public void Constructor_AssemblyRan_ReturnsAssemblyResult()
{
// Setup
var mocks = new MockRepository();
var errorProvider = mocks.Stub <IFailureMechanismSectionResultRowErrorProvider>();
mocks.ReplayAll();
var random = new Random(39);
FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
var result = new NonAdoptableFailureMechanismSectionResult(section);
using (new AssemblyToolCalculatorFactoryConfig())
{
var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance;
FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator;
calculator.FailureMechanismSectionAssemblyResultOutput = new FailureMechanismSectionAssemblyResultWrapper(
new FailureMechanismSectionAssemblyResult(random.NextDouble(), random.NextDouble(), random.NextDouble(),
random.NextEnumValue <FailureMechanismSectionAssemblyGroup>()),
random.NextEnumValue <AssemblyMethod>(), random.NextEnumValue <AssemblyMethod>());
// Call
var row = new NonAdoptableFailureMechanismSectionResultRow(result, errorProvider, new AssessmentSectionStub(), ConstructionProperties);
// Assert
FailureMechanismSectionAssemblyResult calculatorOutput = calculator.FailureMechanismSectionAssemblyResultOutput.AssemblyResult;
Assert.AreEqual(calculatorOutput.SectionProbability, row.SectionProbability);
Assert.AreEqual(EnumDisplayNameHelper.GetDisplayName(calculatorOutput.FailureMechanismSectionAssemblyGroup),
row.AssemblyGroup);
}
mocks.VerifyAll();
}
private static IEnumerable <MapFeature> CreateAssemblyGroupFeatures <TSectionResult>(
IEnumerable <TSectionResult> sectionResults, Func <TSectionResult, FailureMechanismSectionAssemblyResult> performAssemblyFunc)
where TSectionResult : FailureMechanismSectionResult
{
foreach (TSectionResult sectionResult in sectionResults)
{
MapFeature feature = RiskeerMapDataFeaturesFactory.CreateSingleLineMapFeature(sectionResult.Section.Points);
FailureMechanismSectionAssemblyResult assemblyResult;
try
{
assemblyResult = performAssemblyFunc(sectionResult);
}
catch (AssemblyException)
{
continue;
}
feature.MetaData[Resources.AssemblyGroup_DisplayName] =
EnumDisplayNameHelper.GetDisplayName(assemblyResult.FailureMechanismSectionAssemblyGroup);
feature.MetaData[Resources.AssemblyMapDataFeaturesFactory_ProbabilityPerSection_DisplayName] = assemblyResult.SectionProbability;
yield return(feature);
}
}
private static FilterMetamodel AutoResolveFilterConfigurationForColumn <TColumn>()
{
Dictionary <string, string> selectFilterMap = null;
var filterOperator = FilterOperator.Auto;
var columnType = typeof(TColumn).GetRealType();
if (columnType == typeof(string))
{
filterOperator = FilterOperator.Like;
}
else if (columnType == typeof(DateTime))
{
filterOperator = FilterOperator.DateEquals;
}
else if (columnType.IsEnum)
{
selectFilterMap = EnumDisplayNameHelper.GetValueAndDescriptionMap(columnType);
filterOperator = FilterOperator.Select;
}
else if (columnType.IsValueType)
{
// TODO: change to Equals
filterOperator = FilterOperator.Disabled;
}
return(new FilterMetamodel(filterOperator, selectFilterMap));
}
public void Constructor_AssemblyRan_ReturnsAssemblyResult()
{
// Setup
var mocks = new MockRepository();
var errorProvider = mocks.Stub <IFailureMechanismSectionResultRowWithCalculatedProbabilityErrorProvider>();
mocks.ReplayAll();
FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
var result = new AdoptableFailureMechanismSectionResult(section);
FailureMechanismSectionAssemblyResultWrapper assemblyResultWrapper = FailureMechanismSectionAssemblyResultWrapperTestFactory.Create();
Func <FailureMechanismSectionAssemblyResultWrapper> performAssemblyFunc = () => assemblyResultWrapper;
// Call
var row = new AdoptableFailureMechanismSectionResultRow(result, () => double.NaN, errorProvider,
performAssemblyFunc, ConstructionProperties);
// Assert
var assemblyResult = assemblyResultWrapper.AssemblyResult;
Assert.AreEqual(assemblyResult.SectionProbability, row.SectionProbability);
Assert.AreEqual(EnumDisplayNameHelper.GetDisplayName(assemblyResult.FailureMechanismSectionAssemblyGroup),
row.AssemblyGroup);
mocks.VerifyAll();
}
/// <summary>
/// Asserts whether the <see cref="MapData"/> contains the data that is representative
/// for the <paramref name="expectedAssemblyResult"/>.
/// </summary>
/// <param name="failureMechanism">The <see cref="IFailureMechanism"/> the that contains the original data.</param>
/// <param name="expectedAssemblyResult">The expected <see cref="FailureMechanismSectionAssemblyResult"/> that contains the original data.</param>
/// <param name="mapData">The <see cref="MapDataCollection"/> that needs to be asserted.</param>
/// <exception cref="AssertionException">Thrown when:
/// <list type="bullet">
/// <item>the name of the <see cref="MapData"/> is not <c>Duidingsklasse per vak</c>;</item>
/// <item>the amount of features in <paramref name="mapData"/> is not equal to the
/// amount of the <see cref="IFailureMechanism.Sections"/>;</item>
/// <item>the geometries of the features in <paramref name="mapData"/> are not equal to
/// the expected geometry of the <see cref="IFailureMechanism.Sections"/>;</item>
/// <item>the meta data does not contain the <see cref="FailureMechanismSectionAssemblyGroup"/>.</item>
/// </list>
/// </exception>
public static void AssertAssemblyMapData(IFailureMechanism failureMechanism,
FailureMechanismSectionAssemblyResult expectedAssemblyResult,
MapData mapData)
{
var assemblyMapLineData = (MapLineData)mapData;
Assert.AreEqual("Duidingsklasse per vak", assemblyMapLineData.Name);
MapFeature[] features = assemblyMapLineData.Features.ToArray();
FailureMechanismSection[] sections = failureMechanism.Sections.ToArray();
Assert.AreEqual(sections.Length, features.Length);
for (var index = 0; index < sections.Length; index++)
{
MapFeature feature = features[index];
FailureMechanismSection failureMechanismSection = sections[index];
CollectionAssert.AreEqual(failureMechanismSection.Points, feature.MapGeometries.Single().PointCollections.Single());
Assert.AreEqual(2, feature.MetaData.Count);
Assert.AreEqual(EnumDisplayNameHelper.GetDisplayName(expectedAssemblyResult.FailureMechanismSectionAssemblyGroup),
feature.MetaData["Duidingsklasse"]);
Assert.AreEqual(expectedAssemblyResult.SectionProbability, feature.MetaData["Rekenwaarde faalkans per vak"]);
}
}
public void GetDisplayName_WithValidEnumWithAndWithoutDisplayNameAttribute_ReturnsExpectedDisplayName(TestEnum value, string expectedDisplayName)
{
// Call
string displayName = EnumDisplayNameHelper.GetDisplayName(value);
// Assert
Assert.AreEqual(expectedDisplayName, displayName);
}
public static IHtmlString EnumDisplayFor <TModel, TEnum>(this HtmlHelper <TModel> html, Expression <Func <TModel, TEnum> > expression)
{
var metadata = ModelMetadata.FromLambdaExpression(expression, html.ViewData);
var enumType = metadata.ModelType.GetRealType();
var name = EnumDisplayNameHelper.GetDisplayName(enumType, metadata.Model);
return(html.Raw(name));
}
private static void AssertAssemblyGroupMapFeature(FailureMechanismSection section, MapFeature mapFeature, FailureMechanismSectionAssemblyResult expectedAssemblyResult)
{
IEnumerable <MapGeometry> mapGeometries = mapFeature.MapGeometries;
Assert.AreEqual(1, mapGeometries.Count());
CollectionAssert.AreEqual(section.Points, mapGeometries.Single().PointCollections.First());
Assert.AreEqual(2, mapFeature.MetaData.Keys.Count);
Assert.AreEqual(EnumDisplayNameHelper.GetDisplayName(expectedAssemblyResult.FailureMechanismSectionAssemblyGroup),
mapFeature.MetaData["Duidingsklasse"]);
Assert.AreEqual(expectedAssemblyResult.SectionProbability, mapFeature.MetaData["Rekenwaarde faalkans per vak"]);
}
private static List <SelectListItem> GetDropDownItems(PropertyInfo property)
{
var enumValues = EnumDisplayNameHelper.GetValueNameMap(property.PropertyType);
var items = enumValues.Select(enumValue => new SelectListItem
{
Value = enumValue.Key.ToString(CultureInfo.InvariantCulture),
Text = enumValue.Value,
}).ToList();
return(items);
}
/// <summary>
/// Sets the value of <paramref name="result"/> on the control.
/// </summary>
/// <param name="result">The <see cref="AssessmentSectionAssemblyResult"/> to set on the control.</param>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="result"/> is <c>null</c>.</exception>
/// <exception cref="InvalidEnumArgumentException">Thrown when <paramref name="result"/>
/// has an invalid value for <see cref="AssessmentSectionAssemblyGroup"/>.</exception>
/// <exception cref="NotSupportedException">Thrown when <paramref name="result"/>
/// is not supported.</exception>
public void SetAssemblyResult(AssessmentSectionAssemblyResult result)
{
if (result == null)
{
throw new ArgumentNullException(nameof(result));
}
groupLabel.Text = EnumDisplayNameHelper.GetDisplayName(result.AssemblyGroup);
groupLabel.BackColor = AssessmentSectionAssemblyGroupColorHelper.GetAssessmentSectionAssemblyGroupColor(result.AssemblyGroup);
probabilityLabel.Text = ProbabilityFormattingHelper.FormatWithDiscreteNumbers(result.Probability);
}
public void GetProperties_ValuesNaN_ReturnsExpectedValues()
{
// Setup
var convergence = new Random().NextEnumValue <CalculationConvergence>();
// Call
var properties = new WaveConditionsOutputProperties
{
Data = new WaveConditionsOutput(double.NaN, double.NaN, double.NaN, double.NaN, double.NaN, double.NaN,
double.NaN, double.NaN, double.NaN, convergence)
};
// Assert
Assert.IsNaN(properties.WaterLevel);
TestHelper.AssertTypeConverter <WaveConditionsOutputProperties, NoValueRoundedDoubleConverter>(
nameof(WaveConditionsOutputProperties.WaterLevel));
Assert.IsNaN(properties.WaveHeight);
TestHelper.AssertTypeConverter <WaveConditionsOutputProperties, NoValueRoundedDoubleConverter>(
nameof(WaveConditionsOutputProperties.WaveHeight));
Assert.IsNaN(properties.WavePeakPeriod);
TestHelper.AssertTypeConverter <WaveConditionsOutputProperties, NoValueRoundedDoubleConverter>(
nameof(WaveConditionsOutputProperties.WavePeakPeriod));
Assert.IsNaN(properties.WaveDirection);
TestHelper.AssertTypeConverter <WaveConditionsOutputProperties, NoValueRoundedDoubleConverter>(
nameof(WaveConditionsOutputProperties.WaveDirection));
Assert.IsNaN(properties.WaveAngle);
TestHelper.AssertTypeConverter <WaveConditionsOutputProperties, NoValueRoundedDoubleConverter>(
nameof(WaveConditionsOutputProperties.WaveAngle));
Assert.IsNaN(properties.TargetProbability);
TestHelper.AssertTypeConverter <WaveConditionsOutputProperties, NoProbabilityValueDoubleConverter>(
nameof(WaveConditionsOutputProperties.TargetProbability));
Assert.IsNaN(properties.TargetReliability);
TestHelper.AssertTypeConverter <WaveConditionsOutputProperties, NoValueRoundedDoubleConverter>
(nameof(WaveConditionsOutputProperties.TargetReliability));
Assert.IsNaN(properties.CalculatedProbability);
TestHelper.AssertTypeConverter <WaveConditionsOutputProperties, NoProbabilityValueDoubleConverter>(
nameof(WaveConditionsOutputProperties.CalculatedProbability));
Assert.IsNaN(properties.CalculatedReliability);
TestHelper.AssertTypeConverter <WaveConditionsOutputProperties, NoValueRoundedDoubleConverter>(
nameof(WaveConditionsOutputProperties.CalculatedReliability));
string convergenceValue = EnumDisplayNameHelper.GetDisplayName(convergence);
Assert.AreEqual(convergenceValue, properties.Convergence);
}
public void GivenRowWithoutAssemblyErrors_WhenUpdatingAndPerformAssemblyThrowsException_ThenShowError()
{
// Given
var mocks = new MockRepository();
var errorProvider = mocks.Stub <IFailureMechanismSectionResultRowErrorProvider>();
mocks.ReplayAll();
FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
var result = new NonAdoptableWithProfileProbabilityFailureMechanismSectionResult(section);
var nrOfCalls = 0;
FailureMechanismSectionAssemblyResultWrapper assemblyResultWrapper = FailureMechanismSectionAssemblyResultWrapperTestFactory.Create();
Func <FailureMechanismSectionAssemblyResultWrapper> performAssemblyFunc = () =>
{
if (nrOfCalls == 1)
{
throw new AssemblyException();
}
nrOfCalls++;
return(assemblyResultWrapper);
};
var row = new NonAdoptableWithProfileProbabilityFailureMechanismSectionResultRow(result, errorProvider, performAssemblyFunc, ConstructionProperties);
// Precondition
FailureMechanismSectionAssemblyResult assemblyResult = assemblyResultWrapper.AssemblyResult;
Assert.AreEqual(assemblyResult.ProfileProbability, row.ProfileProbability);
Assert.AreEqual(assemblyResult.SectionProbability, row.SectionProbability);
Assert.AreEqual(assemblyResult.N, row.SectionN, row.SectionN.GetAccuracy());
Assert.AreEqual(2, row.SectionN.NumberOfDecimalPlaces);
Assert.AreEqual(EnumDisplayNameHelper.GetDisplayName(assemblyResult.FailureMechanismSectionAssemblyGroup),
row.AssemblyGroup);
// When
row.InitialFailureMechanismResultType = NonAdoptableInitialFailureMechanismResultType.NoFailureProbability;
// Then
var expectedAssemblyResult = new DefaultFailureMechanismSectionAssemblyResult();
Assert.AreEqual(expectedAssemblyResult.ProfileProbability, row.ProfileProbability);
Assert.AreEqual(expectedAssemblyResult.SectionProbability, row.SectionProbability);
Assert.AreEqual(expectedAssemblyResult.N, row.SectionN, row.SectionN.GetAccuracy());
Assert.AreEqual(2, row.SectionN.NumberOfDecimalPlaces);
Assert.AreEqual(EnumDisplayNameHelper.GetDisplayName(expectedAssemblyResult.FailureMechanismSectionAssemblyGroup),
row.AssemblyGroup);
mocks.VerifyAll();
}
public void GetDisplayName_WithInvalidEnum_ThrowsInvalidEnumArgumentException()
{
// Setup
const TestEnum invalidValue = (TestEnum)99;
// Call
void Call() => EnumDisplayNameHelper.GetDisplayName(invalidValue);
// Assert
var expectedMessage = $"The value of argument 'value' ({invalidValue}) is invalid for Enum type '{nameof(TestEnum)}'.";
string parameterName = TestHelper.AssertThrowsArgumentExceptionAndTestMessage <InvalidEnumArgumentException>(Call, expectedMessage).ParamName;
Assert.AreEqual("value", parameterName);
}
public void CreateCombinedFailureMechanismSectionAssemblyFeatures_WithAssessmentSection_ReturnsFeatureCollection()
{
// Setup
var random = new Random(21);
var assessmentSection = new AssessmentSection(random.NextEnumValue <AssessmentSectionComposition>());
assessmentSection.ReferenceLine.SetGeometry(new[]
{
new Point2D(0, 0),
new Point2D(2, 2)
});
using (new AssemblyToolCalculatorFactoryConfig())
{
var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance;
AssessmentSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedAssessmentSectionAssemblyCalculator;
CombinedFailureMechanismSectionAssembly[] failureMechanismSectionAssembly =
{
CombinedFailureMechanismSectionAssemblyTestFactory.Create(assessmentSection, 20),
CombinedFailureMechanismSectionAssemblyTestFactory.Create(assessmentSection, 21)
};
calculator.CombinedFailureMechanismSectionAssemblyOutput = new CombinedFailureMechanismSectionAssemblyResultWrapper(
failureMechanismSectionAssembly, AssemblyMethod.BOI3A1, AssemblyMethod.BOI3B1, AssemblyMethod.BOI3C1);
// Call
IEnumerable <MapFeature> features = AssessmentSectionAssemblyMapDataFeaturesFactory.CreateCombinedFailureMechanismSectionAssemblyFeatures(assessmentSection);
// Assert
IEnumerable <CombinedFailureMechanismSectionAssemblyResult> expectedAssemblyResults =
AssessmentSectionAssemblyFactory.AssembleCombinedPerFailureMechanismSection(assessmentSection);
int expectedNrOfResults = expectedAssemblyResults.Count();
Assert.AreEqual(expectedNrOfResults, features.Count());
for (var i = 0; i < expectedNrOfResults; i++)
{
CombinedFailureMechanismSectionAssemblyResult expectedAssemblyResult = expectedAssemblyResults.ElementAt(i);
MapFeature actualFeature = features.ElementAt(i);
MapGeometry mapGeometry = actualFeature.MapGeometries.Single();
AssertEqualPointCollections(assessmentSection.ReferenceLine,
expectedAssemblyResult,
mapGeometry);
Assert.AreEqual(1, actualFeature.MetaData.Keys.Count);
Assert.AreEqual(EnumDisplayNameHelper.GetDisplayName(expectedAssemblyResult.TotalResult),
features.ElementAt(i).MetaData["Duidingsklasse"]);
}
}
}
public void ToString_Always_ReturnsAssemblyGroupDisplayName()
{
// Setup
var random = new Random(39);
var assemblyGroup = random.NextEnumValue <FailureMechanismSectionAssemblyGroup>();
var properties = new FailureMechanismSectionAssemblyGroupProperties(new FailureMechanismSectionAssemblyGroupBoundaries(random.NextDouble(),
random.NextDouble(),
assemblyGroup));
// Call
var result = properties.ToString();
// Assert
Assert.AreEqual(EnumDisplayNameHelper.GetDisplayName(assemblyGroup), result);
}
public void GivenRowWithoutAssemblyErrors_WhenUpdatingAndAssemblyThrowsException_ThenAssemblyPropertiesSetToDefault()
{
// Given
var mocks = new MockRepository();
var errorProvider = mocks.Stub <IFailureMechanismSectionResultRowWithCalculatedProbabilityErrorProvider>();
mocks.ReplayAll();
FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
var result = new AdoptableFailureMechanismSectionResult(section);
var nrOfCalls = 0;
FailureMechanismSectionAssemblyResultWrapper assemblyResultWrapper = FailureMechanismSectionAssemblyResultWrapperTestFactory.Create();
Func <FailureMechanismSectionAssemblyResultWrapper> performAssemblyFunc = () =>
{
if (nrOfCalls == 1)
{
throw new AssemblyException();
}
nrOfCalls++;
return(assemblyResultWrapper);
};
var row = new AdoptableFailureMechanismSectionResultRow(result, () => double.NaN, errorProvider,
performAssemblyFunc, ConstructionProperties);
// Precondition
FailureMechanismSectionAssemblyResult assemblyResult = assemblyResultWrapper.AssemblyResult;
Assert.AreEqual(assemblyResult.SectionProbability, row.SectionProbability);
Assert.AreEqual(EnumDisplayNameHelper.GetDisplayName(assemblyResult.FailureMechanismSectionAssemblyGroup),
row.AssemblyGroup);
// When
row.InitialFailureMechanismResultType = AdoptableInitialFailureMechanismResultType.Manual;
// Then
var expectedAssemblyResult = new DefaultFailureMechanismSectionAssemblyResult();
Assert.AreEqual(expectedAssemblyResult.SectionProbability, row.SectionProbability);
Assert.AreEqual(EnumDisplayNameHelper.GetDisplayName(expectedAssemblyResult.FailureMechanismSectionAssemblyGroup),
row.AssemblyGroup);
mocks.VerifyAll();
}
public static IHtmlString EnumDropDownListFor <TModel, TEnum>(this HtmlHelper <TModel> html, Expression <Func <TModel, TEnum> > expression)
{
var metadata = ModelMetadata.FromLambdaExpression(expression, html.ViewData);
var enumType = metadata.ModelType.GetRealType();
var enumValues = EnumDisplayNameHelper.GetValueNameMap(enumType);
var selectedValue = (int)metadata.Model;
var items = enumValues.Select(enumValue => new SelectListItem
{
Value = enumValue.Key.ToString(CultureInfo.InvariantCulture),
Text = enumValue.Value,
Selected = enumValue.Key == selectedValue
});
// TODO: pass as parameter
return(html.DropDownListFor(expression, items, "Select", null));
}
public void Data_WithCalculationOutput_ReturnsExpectedValues()
{
// Setup
var items = new[]
{
new TestWaveConditionsOutput()
};
var waveImpactAsphaltCoverWaveConditionsOutput = new WaveImpactAsphaltCoverWaveConditionsOutput(items);
// Call
var properties = new WaveImpactAsphaltCoverWaveConditionsOutputProperties
{
Data = waveImpactAsphaltCoverWaveConditionsOutput
};
// Assert
CollectionAssert.AllItemsAreInstancesOfType(properties.Items, typeof(WaveConditionsOutputProperties));
Assert.AreEqual(items.Length, properties.Items.Length);
WaveConditionsOutput expectedOutputProperty = items[0];
WaveConditionsOutputProperties firstOutputProperties = properties.Items[0];
Assert.AreEqual(expectedOutputProperty.WaterLevel, firstOutputProperties.WaterLevel);
Assert.AreEqual(expectedOutputProperty.WaveHeight, firstOutputProperties.WaveHeight);
Assert.AreEqual(expectedOutputProperty.WavePeakPeriod, firstOutputProperties.WavePeakPeriod);
Assert.AreEqual(expectedOutputProperty.WaveAngle, firstOutputProperties.WaveAngle);
Assert.AreEqual(expectedOutputProperty.WaveDirection, firstOutputProperties.WaveDirection);
Assert.AreEqual(expectedOutputProperty.TargetProbability, firstOutputProperties.TargetProbability);
Assert.AreEqual(expectedOutputProperty.TargetReliability, firstOutputProperties.TargetReliability,
firstOutputProperties.TargetReliability.GetAccuracy());
Assert.AreEqual(expectedOutputProperty.TargetProbability, firstOutputProperties.TargetProbability);
Assert.AreEqual(expectedOutputProperty.TargetReliability, firstOutputProperties.TargetReliability,
firstOutputProperties.TargetReliability.GetAccuracy());
string convergenceValue = EnumDisplayNameHelper.GetDisplayName(expectedOutputProperty.CalculationConvergence);
Assert.AreEqual(convergenceValue, firstOutputProperties.Convergence);
}
public void GetProperties_ValidData_ReturnsExpectedValues()
{
// Setup
var duneLocation = new TestDuneLocation();
var duneLocationCalculation = new DuneLocationCalculation(duneLocation);
// Call
var properties = new DuneLocationCalculationProperties(duneLocationCalculation);
// Assert
Assert.AreEqual(duneLocation.Id, properties.Id);
Assert.AreEqual(duneLocation.Name, properties.Name);
Assert.AreEqual(duneLocation.CoastalAreaId, properties.CoastalAreaId);
Assert.AreEqual(duneLocation.Offset.ToString("0.#", CultureInfo.InvariantCulture), properties.Offset);
Assert.AreEqual(duneLocation.Location, properties.Location);
Assert.IsNaN(properties.WaterLevel);
Assert.IsNaN(properties.WaveHeight);
Assert.IsNaN(properties.WavePeriod);
Assert.IsNaN(properties.TargetProbability);
TestHelper.AssertTypeConverter <DuneLocationCalculationProperties, NoProbabilityValueDoubleConverter>(
nameof(DuneLocationCalculationProperties.TargetProbability));
Assert.IsNaN(properties.TargetReliability);
TestHelper.AssertTypeConverter <DuneLocationCalculationProperties, NoValueRoundedDoubleConverter>(
nameof(DuneLocationCalculationProperties.TargetReliability));
Assert.IsNaN(properties.CalculatedProbability);
TestHelper.AssertTypeConverter <DuneLocationCalculationProperties, NoProbabilityValueDoubleConverter>(
nameof(DuneLocationCalculationProperties.CalculatedProbability));
Assert.IsNaN(properties.CalculatedReliability);
TestHelper.AssertTypeConverter <DuneLocationCalculationProperties, NoValueRoundedDoubleConverter>(
nameof(DuneLocationCalculationProperties.CalculatedReliability));
string convergenceValue = EnumDisplayNameHelper.GetDisplayName(CalculationConvergence.NotCalculated);
Assert.AreEqual(convergenceValue, properties.Convergence);
}
public void GivenRowWithoutAssemblyErrors_WhenUpdatingAndAssemblyThrowsException_ThenAssemblyPropertiesSetToDefault()
{
// Given
var mocks = new MockRepository();
var errorProvider = mocks.Stub <IFailureMechanismSectionResultRowErrorProvider>();
mocks.ReplayAll();
FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
var result = new NonAdoptableFailureMechanismSectionResult(section);
using (new AssemblyToolCalculatorFactoryConfig())
{
var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance;
FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator;
var row = new NonAdoptableFailureMechanismSectionResultRow(result, errorProvider, new AssessmentSectionStub(), ConstructionProperties);
// Precondition
FailureMechanismSectionAssemblyResult calculatorOutput = calculator.FailureMechanismSectionAssemblyResultOutput.AssemblyResult;
Assert.AreEqual(calculatorOutput.SectionProbability, row.SectionProbability);
Assert.AreEqual(EnumDisplayNameHelper.GetDisplayName(calculatorOutput.FailureMechanismSectionAssemblyGroup),
row.AssemblyGroup);
// When
calculator.ThrowExceptionOnCalculate = true;
row.InitialFailureMechanismResultType = NonAdoptableInitialFailureMechanismResultType.NoFailureProbability;
// Then
var expectedAssemblyResult = new DefaultFailureMechanismSectionAssemblyResult();
Assert.AreEqual(expectedAssemblyResult.SectionProbability, row.SectionProbability);
Assert.AreEqual(EnumDisplayNameHelper.GetDisplayName(expectedAssemblyResult.FailureMechanismSectionAssemblyGroup),
row.AssemblyGroup);
}
mocks.VerifyAll();
}
public void GetProperties_ValidData_ReturnsExpectedValues()
{
// Setup
const double waterLevel = 3.09378;
const double waveHeight = 4.29884;
const double wavePeakPeriod = 0.19435;
const double waveAngle = 180.62353;
const double waveDirection = 230.5326;
const double targetProbability = 0.5;
const double targetReliability = 3000;
const double calculatedProbability = 0.4;
const double calculatedReliability = 6000;
var convergence = new Random().NextEnumValue <CalculationConvergence>();
// Call
var properties = new WaveConditionsOutputProperties
{
Data = new WaveConditionsOutput(waterLevel, waveHeight, wavePeakPeriod, waveAngle, waveDirection, targetProbability,
targetReliability, calculatedProbability, calculatedReliability, convergence)
};
// Assert
Assert.AreEqual(waterLevel, properties.WaterLevel, properties.WaterLevel.GetAccuracy());
Assert.AreEqual(waveHeight, properties.WaveHeight, properties.WaveHeight.GetAccuracy());
Assert.AreEqual(wavePeakPeriod, properties.WavePeakPeriod, properties.WavePeakPeriod.GetAccuracy());
Assert.AreEqual(waveDirection, properties.WaveDirection, properties.WaveDirection.GetAccuracy());
Assert.AreEqual(waveAngle, properties.WaveAngle, properties.WaveAngle.GetAccuracy());
Assert.AreEqual(targetProbability, properties.TargetProbability);
Assert.AreEqual(targetReliability, properties.TargetReliability, properties.TargetReliability.GetAccuracy());
Assert.AreEqual(calculatedProbability, properties.CalculatedProbability);
Assert.AreEqual(calculatedReliability, properties.CalculatedReliability, properties.CalculatedReliability.GetAccuracy());
string convergenceValue = EnumDisplayNameHelper.GetDisplayName(convergence);
Assert.AreEqual(convergenceValue, properties.Convergence);
}
private static string GetDisplayNameForFailureMechanism(FailureMechanismSectionAssemblyGroup?failureMechanismSectionAssemblyGroup)
{
return(failureMechanismSectionAssemblyGroup.HasValue
? EnumDisplayNameHelper.GetDisplayName(failureMechanismSectionAssemblyGroup.Value)
: Resources.CombinedFailureMechanismSectionAssemblyResultRow_Not_in_assembly_dash);
}
private static void AssertGroupLabel(AssessmentSectionAssemblyGroup result, BorderedLabel groupLabel)
{
Assert.AreEqual(EnumDisplayNameHelper.GetDisplayName(result), groupLabel.Text);
Assert.AreEqual(AssessmentSectionAssemblyGroupColorHelper.GetAssessmentSectionAssemblyGroupColor(result),
groupLabel.BackColor);
}
public override string ToString()
{
return(EnumDisplayNameHelper.GetDisplayName(data.FailureMechanismSectionAssemblyGroup));
}
private static string GetExpectedDisplayNameForFailureMechanism(FailureMechanismSectionAssemblyGroup?failureMechanismSectionAssemblyGroup)
{
return(failureMechanismSectionAssemblyGroup.HasValue
? EnumDisplayNameHelper.GetDisplayName(failureMechanismSectionAssemblyGroup.Value)
: "-");
}
public override string ToString()
{
return(EnumDisplayNameHelper.GetDisplayName(Group));
}
public void Constructor_WithCombinedFailureMechanismAssemblyResult_ExpectedValues(bool failureMechanismsInAssembly)
{
// Setup
CombinedFailureMechanismSectionAssemblyResult result = GetCombinedFailureMechanismSectionAssemblyResult(failureMechanismsInAssembly);
// Call
var row = new CombinedFailureMechanismSectionAssemblyResultRow(result);
// Assert
Assert.IsInstanceOf <IHasColumnStateDefinitions>(row);
IDictionary <int, DataGridViewColumnStateDefinition> columnStateDefinitions = row.ColumnStateDefinitions;
Assert.AreEqual(19, columnStateDefinitions.Count);
DataGridViewControlColumnStateDefinitionTestHelper.AssertColumnStateDefinition(columnStateDefinitions, pipingIndex);
DataGridViewControlColumnStateDefinitionTestHelper.AssertColumnStateDefinition(columnStateDefinitions, grassCoverErosionInwardsIndex);
DataGridViewControlColumnStateDefinitionTestHelper.AssertColumnStateDefinition(columnStateDefinitions, macroStabilityInwardsIndex);
DataGridViewControlColumnStateDefinitionTestHelper.AssertColumnStateDefinition(columnStateDefinitions, microstabililityIndex);
DataGridViewControlColumnStateDefinitionTestHelper.AssertColumnStateDefinition(columnStateDefinitions, stabilityStoneCoverIndex);
DataGridViewControlColumnStateDefinitionTestHelper.AssertColumnStateDefinition(columnStateDefinitions, waveImpactAsphaltCoverIndex);
DataGridViewControlColumnStateDefinitionTestHelper.AssertColumnStateDefinition(columnStateDefinitions, waterPressureAsphaltCoverIndex);
DataGridViewControlColumnStateDefinitionTestHelper.AssertColumnStateDefinition(columnStateDefinitions, grassCoverErosionOutwardsIndex);
DataGridViewControlColumnStateDefinitionTestHelper.AssertColumnStateDefinition(columnStateDefinitions, grassCoverSlipOffOutwardsIndex);
DataGridViewControlColumnStateDefinitionTestHelper.AssertColumnStateDefinition(columnStateDefinitions, grassCoverSlipOffInwardsIndex);
DataGridViewControlColumnStateDefinitionTestHelper.AssertColumnStateDefinition(columnStateDefinitions, heightStructuresIndex);
DataGridViewControlColumnStateDefinitionTestHelper.AssertColumnStateDefinition(columnStateDefinitions, closingStructuresIndex);
DataGridViewControlColumnStateDefinitionTestHelper.AssertColumnStateDefinition(columnStateDefinitions, pipingStructureIndex);
DataGridViewControlColumnStateDefinitionTestHelper.AssertColumnStateDefinition(columnStateDefinitions, stabilityPointStructuresIndex);
DataGridViewControlColumnStateDefinitionTestHelper.AssertColumnStateDefinition(columnStateDefinitions, duneErosionIndex);
for (var i = 0; i < result.SpecificFailureMechanisms.Length; i++)
{
DataGridViewControlColumnStateDefinitionTestHelper.AssertColumnStateDefinition(columnStateDefinitions, specificFailureMechanismStartIndex + i);
}
DataGridViewControlColumnStateDefinitionTestHelper.AssertColumnStateDefinition(columnStateDefinitions, specificFailureMechanismStartIndex + result.SpecificFailureMechanisms.Length);
Assert.AreEqual(2, row.SectionStart.NumberOfDecimalPlaces);
Assert.AreEqual(result.SectionStart, row.SectionStart, row.SectionStart.GetAccuracy());
Assert.AreEqual(2, row.SectionStart.NumberOfDecimalPlaces);
Assert.AreEqual(result.SectionEnd, row.SectionEnd, row.SectionEnd.GetAccuracy());
Assert.AreEqual(GetExpectedDisplayNameForFailureMechanism(result.Piping), row.Piping);
Assert.AreEqual(GetExpectedDisplayNameForFailureMechanism(result.GrassCoverErosionInwards), row.GrassCoverErosionInwards);
Assert.AreEqual(GetExpectedDisplayNameForFailureMechanism(result.MacroStabilityInwards), row.MacroStabilityInwards);
Assert.AreEqual(GetExpectedDisplayNameForFailureMechanism(result.Microstability), row.Microstability);
Assert.AreEqual(GetExpectedDisplayNameForFailureMechanism(result.StabilityStoneCover), row.StabilityStoneCover);
Assert.AreEqual(GetExpectedDisplayNameForFailureMechanism(result.WaveImpactAsphaltCover), row.WaveImpactAsphaltCover);
Assert.AreEqual(GetExpectedDisplayNameForFailureMechanism(result.WaterPressureAsphaltCover), row.WaterPressureAsphaltCover);
Assert.AreEqual(GetExpectedDisplayNameForFailureMechanism(result.GrassCoverErosionOutwards), row.GrassCoverErosionOutwards);
Assert.AreEqual(GetExpectedDisplayNameForFailureMechanism(result.GrassCoverSlipOffOutwards), row.GrassCoverSlipOffOutwards);
Assert.AreEqual(GetExpectedDisplayNameForFailureMechanism(result.GrassCoverSlipOffInwards), row.GrassCoverSlipOffInwards);
Assert.AreEqual(GetExpectedDisplayNameForFailureMechanism(result.HeightStructures), row.HeightStructures);
Assert.AreEqual(GetExpectedDisplayNameForFailureMechanism(result.ClosingStructures), row.ClosingStructures);
Assert.AreEqual(GetExpectedDisplayNameForFailureMechanism(result.PipingStructure), row.PipingStructure);
Assert.AreEqual(GetExpectedDisplayNameForFailureMechanism(result.StabilityPointStructures), row.StabilityPointStructures);
Assert.AreEqual(GetExpectedDisplayNameForFailureMechanism(result.DuneErosion), row.DuneErosion);
for (var i = 0; i < result.SpecificFailureMechanisms.Length; i++)
{
FailureMechanismSectionAssemblyGroup?specificFailureMechanism = result.SpecificFailureMechanisms[i];
Assert.AreEqual(GetExpectedDisplayNameForFailureMechanism(specificFailureMechanism), row.SpecificFailureMechanisms[i]);
}
Assert.AreEqual(EnumDisplayNameHelper.GetDisplayName(result.TotalResult), row.TotalResult);
}
