public void GivenFormWithAssemblyResultTotalViewAndErrorOnAssemblyResult_WhenRefreshingAssemblyResultsWithoutException_ThenAssessmentSectionAssemblyResultsSetAndErrorCleared()
{
// Given
using (new AssemblyToolCalculatorFactoryConfig())
{
var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance;
AssessmentSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedAssessmentSectionAssemblyCalculator;
calculator.ThrowExceptionOnCalculate = true;
using (ShowAssemblyResultTotalView())
{
ButtonTester buttonTester = GetRefreshAssemblyResultButtonTester();
buttonTester.Properties.Enabled = true;
// Precondition
AssertAssessmentSectionAssemblyResultControlWithError();
// When
calculator.ThrowExceptionOnCalculate = false;
buttonTester.Click();
// Then
AssertAssessmentSectionAssemblyResultControl("A+", "1/7");
Assert.IsEmpty(GetProbabilityError(GetAssessmentSectionAssemblyResultControl()));
Assert.IsEmpty(GetGroupError(GetAssessmentSectionAssemblyResultControl()));
}
}
}
public void GivenFormWithAssemblyResultPerSectionView_WhenSpecificFailureMechanismAdded_ThenColumnAdded()
{
// Given
var random = new Random(21);
AssessmentSection assessmentSection = TestDataGenerator.GetAssessmentSectionWithAllFailureMechanismSectionsAndResults(
random.NextEnumValue <AssessmentSectionComposition>());
using (new AssemblyToolCalculatorFactoryConfig())
using (ShowAssemblyResultPerSectionView(assessmentSection))
{
var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance;
AssessmentSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedAssessmentSectionAssemblyCalculator;
// Precondition
DataGridView dataGridView = GetDataGridView();
Assert.AreEqual(20, dataGridView.ColumnCount);
ButtonTester buttonTester = GetRefreshAssemblyResultButtonTester();
// When
const string testCode = "TestCode";
var failureMechanism = new SpecificFailureMechanism
{
Code = testCode
};
assessmentSection.SpecificFailureMechanisms.Add(failureMechanism);
assessmentSection.SpecificFailureMechanisms.NotifyObservers();
calculator.CombinedFailureMechanismSectionAssemblyOutput = null;
buttonTester.Click();
// Then
AssertColumns(dataGridView.Columns, GetExpectedNrOfColumns(assessmentSection), assessmentSection.SpecificFailureMechanisms);
}
}
public void GivenFormWithAssemblyResultPerSectionView_WithOrWithoutErrorSetAndObserverNotified_ThenWarningSetWithPadding(bool withError, int expectedPadding)
{
// Given
AssessmentSection assessmentSection = TestDataGenerator.GetAssessmentSectionWithAllFailureMechanismSectionsAndResults(
new Random(21).NextEnumValue <AssessmentSectionComposition>());
using (new AssemblyToolCalculatorFactoryConfig())
{
var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance;
AssessmentSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedAssessmentSectionAssemblyCalculator;
calculator.ThrowExceptionOnCalculate = withError;
using (AssemblyResultPerSectionView view = ShowAssemblyResultPerSectionView(assessmentSection))
{
// Precondition
ButtonTester buttonTester = GetRefreshAssemblyResultButtonTester();
Button button = buttonTester.Properties;
Assert.IsFalse(button.Enabled);
ErrorProvider errorProvider = GetErrorProvider(view);
Assert.AreEqual(withError, !string.IsNullOrEmpty(errorProvider.GetError(button)));
ErrorProvider warningProvider = GetWarningProvider(view);
Assert.IsEmpty(warningProvider.GetError(button));
// When
assessmentSection.NotifyObservers();
// Then
Assert.AreEqual(assemblyResultOutdatedWarning, warningProvider.GetError(button));
Assert.AreEqual(expectedPadding, warningProvider.GetIconPadding(button));
}
}
}
public void GivenFormWithAssemblyResultTotalView_WhenRefreshingAssemblyResults_ThenAssessmentSectionAssemblyResultsUpdatedToNewValues()
{
// Given
using (new AssemblyToolCalculatorFactoryConfig())
using (ShowAssemblyResultTotalView())
{
ButtonTester buttonTester = GetRefreshAssemblyResultButtonTester();
buttonTester.Properties.Enabled = true;
// Precondition
AssertAssessmentSectionAssemblyResultControl("A+", "1/7");
// When
var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance;
AssessmentSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedAssessmentSectionAssemblyCalculator;
calculator.AssessmentSectionAssemblyResult = new AssessmentSectionAssemblyResultWrapper(
new AssessmentSectionAssemblyResult(0.5, AssessmentSectionAssemblyGroup.A),
AssemblyMethod.BOI2A1, AssemblyMethod.BOI2B1);
buttonTester.Click();
// Then
AssertAssessmentSectionAssemblyResultControl("A", "1/2");
}
}
public void Export_InvalidDirectoryRights_LogsErrorAndReturnsFalse()
{
// Setup
string filePath = TestHelper.GetScratchPadPath(nameof(Export_InvalidDirectoryRights_LogsErrorAndReturnsFalse));
AssessmentSection assessmentSection = CreateConfiguredAssessmentSection();
var exporter = new AssemblyExporter(assessmentSection, filePath);
using (var fileDisposeHelper = new FileDisposeHelper(filePath))
using (new AssemblyToolCalculatorFactoryConfig())
{
var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance;
AssessmentSectionAssemblyCalculatorStub assessmentSectionAssemblyCalculator = calculatorFactory.LastCreatedAssessmentSectionAssemblyCalculator;
assessmentSectionAssemblyCalculator.CombinedFailureMechanismSectionAssemblyOutput = new CombinedFailureMechanismSectionAssemblyResultWrapper(
Array.Empty <CombinedFailureMechanismSectionAssembly>(), AssemblyMethod.BOI3A1, AssemblyMethod.BOI3B1, AssemblyMethod.BOI3C1);
fileDisposeHelper.LockFiles();
// Call
var isExported = true;
void Call() => isExported = exporter.Export();
// Assert
string expectedMessage = $"Er is een onverwachte fout opgetreden tijdens het schrijven van het bestand '{filePath}'. " +
"Er zijn geen assemblageresultaten geëxporteerd.";
TestHelper.AssertLogMessageWithLevelIsGenerated(Call, new Tuple <string, LogLevelConstant>(expectedMessage, LogLevelConstant.Error));
Assert.IsFalse(isExported);
}
}
public void CreateCombinedFailureMechanismSectionAssemblyFeatures_AssemblyCalculatorThrowsException_ReturnsEmptyFeatureCollection()
{
// 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;
calculator.ThrowExceptionOnCalculate = true;
// Call
IEnumerable <MapFeature> features = AssessmentSectionAssemblyMapDataFeaturesFactory.CreateCombinedFailureMechanismSectionAssemblyFeatures(assessmentSection);
// Assert
CollectionAssert.IsEmpty(features);
}
}
public void AssembleAssessmentSection_AssessmentSectionContainingFailureMechanismsWithRandomInAssemblyState_SetsInputOnCalculator()
{
// Setup
AssessmentSection assessmentSection = CreateAssessmentSectionContainingFailureMechanismsWithRandomInAssemblyState();
using (new AssemblyToolCalculatorFactoryConfig())
{
var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance;
FailureMechanismAssemblyCalculatorStub failureMechanismAssemblyCalculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator;
AssessmentSectionAssemblyCalculatorStub assessmentSectionAssemblyCalculator = calculatorFactory.LastCreatedAssessmentSectionAssemblyCalculator;
// Call
AssessmentSectionAssemblyFactory.AssembleAssessmentSection(assessmentSection);
// Assert
FailureMechanismContribution contribution = assessmentSection.FailureMechanismContribution;
Assert.AreEqual(contribution.SignalFloodingProbability, assessmentSectionAssemblyCalculator.SignalFloodingProbability);
Assert.AreEqual(contribution.MaximumAllowableFloodingProbability, assessmentSectionAssemblyCalculator.MaximumAllowableFloodingProbabilityInput);
int expectedNrOfProbabilities = assessmentSection.GetFailureMechanisms()
.Concat(assessmentSection.SpecificFailureMechanisms)
.Count(fp => fp.InAssembly);
IEnumerable <double> calculatorInput = assessmentSectionAssemblyCalculator.FailureMechanismProbabilitiesInput;
Assert.AreEqual(expectedNrOfProbabilities, calculatorInput.Count());
foreach (double failureMechanismProbability in calculatorInput)
{
Assert.AreEqual(failureMechanismAssemblyCalculator.AssemblyResultOutput.AssemblyResult, failureMechanismProbability);
}
}
}
/// <summary>
/// Creates a new instance of <see cref="TestAssemblyToolCalculatorFactory"/>.
/// </summary>
public TestAssemblyToolCalculatorFactory()
{
LastCreatedAssessmentSectionAssemblyGroupBoundariesCalculator = new AssessmentSectionAssemblyGroupBoundariesCalculatorStub();
LastCreatedFailureMechanismSectionAssemblyGroupBoundariesCalculator = new FailureMechanismSectionAssemblyGroupBoundariesCalculatorStub();
LastCreatedFailureMechanismSectionAssemblyCalculator = new FailureMechanismSectionAssemblyCalculatorStub();
LastCreatedFailureMechanismAssemblyCalculator = new FailureMechanismAssemblyCalculatorStub();
LastCreatedAssessmentSectionAssemblyCalculator = new AssessmentSectionAssemblyCalculatorStub();
}
public void GivenViewWithAssemblyResults_WhenFailureMechanismNotifiesObserver_ThenAssemblyResultsRefreshed()
{
// Given
var random = new Random(21);
AssessmentSection assessmentSection = CreateAssessmentSectionWithReferenceLine();
using (new AssemblyToolCalculatorFactoryConfig())
{
var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance;
AssessmentSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedAssessmentSectionAssemblyCalculator;
calculator.CombinedFailureMechanismSectionAssemblyOutput = new CombinedFailureMechanismSectionAssemblyResultWrapper(
new[]
{
CombinedFailureMechanismSectionAssemblyTestFactory.Create(assessmentSection, 10)
}, AssemblyMethod.BOI3A1, AssemblyMethod.BOI3B1, AssemblyMethod.BOI3C1);
using (var view = new AssemblyResultPerSectionMapView(assessmentSection))
{
// Precondition
MapDataCollection mapData = view.Map.Data;
var mocks = new MockRepository();
IObserver[] observers = AttachMapDataObservers(mocks, mapData.Collection);
observers[referenceLineIndex].Expect(obs => obs.UpdateObserver());
observers[assemblyResultsObserverIndex].Expect(obs => obs.UpdateObserver());
mocks.ReplayAll();
IEnumerable <CombinedFailureMechanismSectionAssemblyResult> expectedResults =
AssessmentSectionAssemblyFactory.AssembleCombinedPerFailureMechanismSection(assessmentSection);
AssertCombinedFailureMechanismSectionAssemblyResultMapData(expectedResults,
assessmentSection.ReferenceLine,
mapData.Collection.ElementAt(assemblyResultsIndex));
// When
calculator.CombinedFailureMechanismSectionAssemblyOutput = new CombinedFailureMechanismSectionAssemblyResultWrapper(
new[]
{
CombinedFailureMechanismSectionAssemblyTestFactory.Create(assessmentSection, 20)
}, AssemblyMethod.BOI3A1, AssemblyMethod.BOI3B1, AssemblyMethod.BOI3C1);
IEnumerable <IFailureMechanism> failureMechanisms = assessmentSection.GetFailureMechanisms();
failureMechanisms.ElementAt(random.Next(failureMechanisms.Count())).NotifyObservers();
// Then
expectedResults = AssessmentSectionAssemblyFactory.AssembleCombinedPerFailureMechanismSection(assessmentSection);
AssertCombinedFailureMechanismSectionAssemblyResultMapData(expectedResults,
assessmentSection.ReferenceLine,
mapData.Collection.ElementAt(assemblyResultsIndex));
mocks.VerifyAll();
}
}
}
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 Constructor_WithAllData_DataUpdatedToCollectionOfFilledMapData()
{
// Setup
AssessmentSection assessmentSection = CreateAssessmentSectionWithReferenceLine();
assessmentSection.SetHydraulicBoundaryLocationCalculations(new[]
{
new HydraulicBoundaryLocation(1, "test", 1.0, 2.0)
});
// Call
using (new AssemblyToolCalculatorFactoryConfig())
{
var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance;
AssessmentSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedAssessmentSectionAssemblyCalculator;
CombinedFailureMechanismSectionAssembly[] failureMechanismSectionAssembly =
{
CombinedFailureMechanismSectionAssemblyTestFactory.Create(assessmentSection, 21)
};
calculator.CombinedFailureMechanismSectionAssemblyOutput = new CombinedFailureMechanismSectionAssemblyResultWrapper(
failureMechanismSectionAssembly, AssemblyMethod.BOI3A1, AssemblyMethod.BOI3B1, AssemblyMethod.BOI3C1);
using (var view = new AssemblyResultPerSectionMapView(assessmentSection))
{
// Assert
Assert.IsInstanceOf <MapDataCollection>(view.Map.Data);
MapDataCollection mapData = view.Map.Data;
Assert.IsNotNull(mapData);
Assert.AreEqual(3, mapData.Collection.Count());
IEnumerable <CombinedFailureMechanismSectionAssemblyResult> expectedResults =
AssessmentSectionAssemblyFactory.AssembleCombinedPerFailureMechanismSection(assessmentSection);
AssertCombinedFailureMechanismSectionAssemblyResultMapData(expectedResults,
assessmentSection.ReferenceLine,
mapData.Collection.ElementAt(assemblyResultsIndex));
MapData hydraulicBoundaryLocationsMapData = mapData.Collection.ElementAt(hydraulicBoundaryLocationsIndex);
MapDataTestHelper.AssertHydraulicBoundaryLocationsMapData(assessmentSection, hydraulicBoundaryLocationsMapData);
MapData referenceLineMapData = mapData.Collection.ElementAt(referenceLineIndex);
AssertReferenceLineMapData(assessmentSection.ReferenceLine, referenceLineMapData);
}
}
}
private static void SetCombinedFailureMechanismSectionAssemblyOutput(IAssessmentSection assessmentSection)
{
IEnumerable <IFailureMechanism> failureMechanisms = assessmentSection.GetFailureMechanisms()
.Concat(assessmentSection.SpecificFailureMechanisms);
var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance;
AssessmentSectionAssemblyCalculatorStub assessmentSectionAssemblyCalculator = calculatorFactory.LastCreatedAssessmentSectionAssemblyCalculator;
assessmentSectionAssemblyCalculator.CombinedFailureMechanismSectionAssemblyOutput = new CombinedFailureMechanismSectionAssemblyResultWrapper(
new[]
{
new CombinedFailureMechanismSectionAssembly(new CombinedAssemblyFailureMechanismSection(0, 2.5, FailureMechanismSectionAssemblyGroup.II),
failureMechanisms.Select(fm => FailureMechanismSectionAssemblyGroup.II)),
new CombinedFailureMechanismSectionAssembly(new CombinedAssemblyFailureMechanismSection(2.5, 5, FailureMechanismSectionAssemblyGroup.III),
failureMechanisms.Select(fm => FailureMechanismSectionAssemblyGroup.III))
}, AssemblyMethod.BOI3A1, AssemblyMethod.BOI3B1, AssemblyMethod.BOI3C1);
}
public void AssembleAssessmentSection_AssemblyRan_ReturnsOutput()
{
// Setup
AssessmentSection assessmentSection = CreateAssessmentSectionContainingFailureMechanismsWithInAssemblyTrue();
using (new AssemblyToolCalculatorFactoryConfig())
{
var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance;
AssessmentSectionAssemblyCalculatorStub assessmentSectionAssemblyCalculator = calculatorFactory.LastCreatedAssessmentSectionAssemblyCalculator;
// Call
AssessmentSectionAssemblyResultWrapper result = AssessmentSectionAssemblyFactory.AssembleAssessmentSection(assessmentSection);
// Assert
Assert.AreSame(assessmentSectionAssemblyCalculator.AssessmentSectionAssemblyResult, result);
}
}
public void AssembleAssessmentSection_CalculatorThrowsException_ThrowsAssemblyException()
{
// Setup
using (new AssemblyToolCalculatorFactoryConfig())
{
var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance;
AssessmentSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedAssessmentSectionAssemblyCalculator;
calculator.ThrowExceptionOnCalculate = true;
// Call
void Call() => AssessmentSectionAssemblyFactory.AssembleAssessmentSection(CreateAssessmentSectionContainingFailureMechanismsWithInAssemblyTrue());
// Assert
var exception = Assert.Throws <AssemblyException>(Call);
Exception innerException = exception.InnerException;
Assert.IsInstanceOf <AssessmentSectionAssemblyCalculatorException>(innerException);
Assert.AreEqual(innerException.Message, exception.Message);
}
}
public void GivenFormWithAssemblyResultTotalView_WhenRefreshingAssemblyResultsThrowsException_ThenAssessmentSectionAssemblyResultsClearedAndErrorSet()
{
// Given
using (new AssemblyToolCalculatorFactoryConfig())
using (ShowAssemblyResultTotalView())
{
ButtonTester buttonTester = GetRefreshAssemblyResultButtonTester();
buttonTester.Properties.Enabled = true;
// Precondition
AssertAssessmentSectionAssemblyResultControl("A+", "1/7");
// When
var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance;
AssessmentSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedAssessmentSectionAssemblyCalculator;
calculator.ThrowExceptionOnCalculate = true;
buttonTester.Click();
// Then
AssertAssessmentSectionAssemblyResultControlWithError();
}
}
public void AssembleCombinedPerFailureMechanismSection_CalculatorThrowsException_ThrowsAssemblyException()
{
// Setup
var random = new Random(21);
AssessmentSection assessmentSection = TestDataGenerator.GetAssessmentSectionWithAllFailureMechanismSectionsAndResults(
random.NextEnumValue <AssessmentSectionComposition>());
using (new AssemblyToolCalculatorFactoryConfig())
{
var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance;
AssessmentSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedAssessmentSectionAssemblyCalculator;
calculator.ThrowExceptionOnCalculate = true;
// Call
void Call() => AssessmentSectionAssemblyFactory.AssembleCombinedPerFailureMechanismSection(assessmentSection);
// Assert
var exception = Assert.Throws <AssemblyException>(Call);
Exception innerException = exception.InnerException;
Assert.IsInstanceOf <AssessmentSectionAssemblyCalculatorException>(innerException);
Assert.AreEqual(innerException.Message, exception.Message);
}
}
public void AssembleCombinedPerFailureMechanismSection_WithAssessmentSection_SetsInputOnCalculator(bool failureMechanismSectionAssemblyThrowsException)
{
var random = new Random(21);
AssessmentSection assessmentSection = TestDataGenerator.GetAssessmentSectionWithAllFailureMechanismSectionsAndResults(
random.NextEnumValue <AssessmentSectionComposition>());
using (new AssemblyToolCalculatorFactoryConfig())
{
var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance;
FailureMechanismSectionAssemblyCalculatorStub failureMechanismSectionAssemblyCalculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator;
failureMechanismSectionAssemblyCalculator.ThrowExceptionOnCalculate = failureMechanismSectionAssemblyThrowsException;
// Call
AssessmentSectionAssemblyFactory.AssembleCombinedPerFailureMechanismSection(assessmentSection);
// Assert
AssessmentSectionAssemblyCalculatorStub assessmentSectionAssemblyCalculator = calculatorFactory.LastCreatedAssessmentSectionAssemblyCalculator;
IEnumerable <CombinedAssemblyFailureMechanismSection>[] actualInput = assessmentSectionAssemblyCalculator.CombinedFailureMechanismSectionsInput.ToArray();
IEnumerable <CombinedAssemblyFailureMechanismSection>[] expectedInput = CombinedAssemblyFailureMechanismSectionFactory.CreateInput(
assessmentSection, assessmentSection.GetFailureMechanisms().Concat(assessmentSection.SpecificFailureMechanisms)).ToArray();
Assert.AreEqual(expectedInput.Length, actualInput.Length);
for (var i = 0; i < expectedInput.Length; i++)
{
CombinedAssemblyFailureMechanismSection[] actualSections = actualInput[i].ToArray();
CombinedAssemblyFailureMechanismSection[] expectedSections = expectedInput[i].ToArray();
Assert.AreEqual(expectedSections.Length, actualSections.Length);
for (var j = 0; j < expectedSections.Length; j++)
{
Assert.AreEqual(expectedSections[j].SectionStart, actualSections[j].SectionStart);
Assert.AreEqual(expectedSections[j].SectionEnd, actualSections[j].SectionEnd);
Assert.AreEqual(expectedSections[j].FailureMechanismSectionAssemblyGroup, actualSections[j].FailureMechanismSectionAssemblyGroup);
}
}
}
}
public void Export_CalculatorThrowsAssemblyException_LogsErrorAndReturnsFalse()
{
// Setup
string filePath = TestHelper.GetScratchPadPath(nameof(Export_CalculatorThrowsAssemblyException_LogsErrorAndReturnsFalse));
AssessmentSection assessmentSection = CreateConfiguredAssessmentSection();
var exporter = new AssemblyExporter(assessmentSection, filePath);
using (new AssemblyToolCalculatorFactoryConfig())
{
var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance;
AssessmentSectionAssemblyCalculatorStub assessmentSectionAssemblyCalculator = calculatorFactory.LastCreatedAssessmentSectionAssemblyCalculator;
assessmentSectionAssemblyCalculator.ThrowExceptionOnCalculate = true;
// Call
var isExported = true;
void Call() => isExported = exporter.Export();
// Assert
const string expectedMessage = "De assemblage kan niet succesvol worden afgerond. Inspecteer de resultaten van de faalmechanismen die onderdeel zijn van de assemblage of het veiligheidsoordeel voor meer details.";
TestHelper.AssertLogMessageWithLevelIsGenerated(Call, new Tuple <string, LogLevelConstant>(expectedMessage, LogLevelConstant.Error));
Assert.IsFalse(isExported);
}
}
public void AssembleCombinedPerFailureMechanismSection_AssemblyRan_ReturnsOutput()
{
var random = new Random(21);
AssessmentSection assessmentSection = TestDataGenerator.GetAssessmentSectionWithAllFailureMechanismSectionsAndResults(
random.NextEnumValue <AssessmentSectionComposition>());
using (new AssemblyToolCalculatorFactoryConfig())
{
var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance;
AssessmentSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedAssessmentSectionAssemblyCalculator;
calculator.CombinedFailureMechanismSectionAssemblyOutput = new CombinedFailureMechanismSectionAssemblyResultWrapper(
new[]
{
CombinedFailureMechanismSectionAssemblyTestFactory.Create(assessmentSection, 20),
CombinedFailureMechanismSectionAssemblyTestFactory.Create(assessmentSection, 21)
}, AssemblyMethod.BOI3A1, AssemblyMethod.BOI3B1, AssemblyMethod.BOI3C1);
// Call
CombinedFailureMechanismSectionAssemblyResult[] output = AssessmentSectionAssemblyFactory.AssembleCombinedPerFailureMechanismSection(
assessmentSection)
.ToArray();
// Assert
Dictionary <IFailureMechanism, int> failureMechanisms = assessmentSection.GetFailureMechanisms()
.Concat(assessmentSection.SpecificFailureMechanisms)
.Where(fm => fm.InAssembly)
.Select((fm, i) => new
{
FailureMechanism = fm,
Index = i
})
.ToDictionary(x => x.FailureMechanism, x => x.Index);
CombinedFailureMechanismSectionAssemblyResult[] expectedOutput = CombinedFailureMechanismSectionAssemblyResultFactory.Create(
calculator.CombinedFailureMechanismSectionAssemblyOutput, failureMechanisms, assessmentSection).ToArray();
Assert.AreEqual(expectedOutput.Length, output.Length);
for (var i = 0; i < expectedOutput.Length; i++)
{
Assert.AreEqual(expectedOutput[i].SectionStart, output[i].SectionStart);
Assert.AreEqual(expectedOutput[i].SectionEnd, output[i].SectionEnd);
Assert.AreEqual(expectedOutput[i].TotalResult, output[i].TotalResult);
Assert.AreEqual(expectedOutput[i].Piping, output[i].Piping);
Assert.AreEqual(expectedOutput[i].GrassCoverErosionInwards, output[i].GrassCoverErosionInwards);
Assert.AreEqual(expectedOutput[i].MacroStabilityInwards, output[i].MacroStabilityInwards);
Assert.AreEqual(expectedOutput[i].Microstability, output[i].Microstability);
Assert.AreEqual(expectedOutput[i].StabilityStoneCover, output[i].StabilityStoneCover);
Assert.AreEqual(expectedOutput[i].WaveImpactAsphaltCover, output[i].WaveImpactAsphaltCover);
Assert.AreEqual(expectedOutput[i].WaterPressureAsphaltCover, output[i].WaterPressureAsphaltCover);
Assert.AreEqual(expectedOutput[i].GrassCoverErosionOutwards, output[i].GrassCoverErosionOutwards);
Assert.AreEqual(expectedOutput[i].GrassCoverSlipOffOutwards, output[i].GrassCoverSlipOffOutwards);
Assert.AreEqual(expectedOutput[i].GrassCoverSlipOffInwards, output[i].GrassCoverSlipOffInwards);
Assert.AreEqual(expectedOutput[i].HeightStructures, output[i].HeightStructures);
Assert.AreEqual(expectedOutput[i].ClosingStructures, output[i].ClosingStructures);
Assert.AreEqual(expectedOutput[i].PipingStructure, output[i].PipingStructure);
Assert.AreEqual(expectedOutput[i].StabilityPointStructures, output[i].StabilityPointStructures);
Assert.AreEqual(expectedOutput[i].DuneErosion, output[i].DuneErosion);
CollectionAssert.AreEqual(expectedOutput[i].SpecificFailureMechanisms, output[i].SpecificFailureMechanisms);
Assert.AreEqual(expectedOutput[i].CommonSectionAssemblyMethod, output[i].CommonSectionAssemblyMethod);
Assert.AreEqual(expectedOutput[i].FailureMechanismResultsAssemblyMethod, output[i].FailureMechanismResultsAssemblyMethod);
Assert.AreEqual(expectedOutput[i].CombinedSectionResultAssemblyMethod, output[i].CombinedSectionResultAssemblyMethod);
}
}
}
