private static void TestCombinedSectionsFinalResultsTemporal(BenchmarkTestInput input,
BenchmarkTestResult result)
{
var assembler = new CommonFailureMechanismSectionAssembler();
var calculatedResults = assembler
.DetermineCombinedResultPerCommonSectionWbi3C1(
input.ExpectedCombinedSectionResultPerFailureMechanism,
true).ToArray();
var expectedResults = input.ExpectedCombinedSectionResultTemporal.ToArray();
try
{
Assert.AreEqual(expectedResults.Length, calculatedResults.Length);
for (int i = 0; i < expectedResults.Length; i++)
{
Assert.AreEqual(expectedResults[i].SectionStart, calculatedResults[i].SectionStart, 0.01);
Assert.AreEqual(expectedResults[i].SectionEnd, calculatedResults[i].SectionEnd, 0.01);
Assert.AreEqual(expectedResults[i].Category, calculatedResults[i].Category);
}
result.AreEqualAssemblyResultCombinedSectionsResultsTemporal = true;
result.MethodResults.Wbi3C1T = true;
}
catch (AssertionException)
{
result.AreEqualAssemblyResultCombinedSectionsResultsTemporal = false;
result.MethodResults.Wbi3C1T = false;
}
}
public void ReaderReadsFailureMechanismWithoutLengthEffectInformationCorrectly()
{
var testFile = Path.Combine(GetTestDir(), "Benchmarktool assemblage - Failure mechanism without length-effect.xlsx");
using (SpreadsheetDocument spreadsheetDocument = SpreadsheetDocument.Open(testFile, false))
{
WorkbookPart workbookPart = spreadsheetDocument.WorkbookPart;
var workSheetParts = ReadWorkSheetParts(workbookPart);
var workSheetPart = workSheetParts["Sheet1"];
var reader = new FailureMechanismsReader(workSheetPart, workbookPart);
var result = new BenchmarkTestInput();
reader.Read(result, "GEKB");
Assert.AreEqual(1, result.ExpectedFailureMechanismsResults.Count);
ExpectedFailureMechanismResult expectedFailureMechanismResult =
result.ExpectedFailureMechanismsResults.First();
Assert.AreEqual(false, expectedFailureMechanismResult.HasLengthEffect);
Assert.AreEqual("GEKB", expectedFailureMechanismResult.MechanismId);
Assert.AreEqual(4.46E-06, expectedFailureMechanismResult.ExpectedCombinedProbability, 1E-4);
Assert.AreEqual(4.46E-06, expectedFailureMechanismResult.ExpectedCombinedProbabilityTemporal, 1E-4);
}
}
/// <summary>
/// Reads the general information of an assessment section.
/// </summary>
/// <param name="benchmarkTestInput">The test input.</param>
public void Read(BenchmarkTestInput benchmarkTestInput)
{
benchmarkTestInput.SignalingNorm = GetCellValueAsDouble("B", "Signaleringskans");
benchmarkTestInput.LowerBoundaryNorm = GetCellValueAsDouble("B", "Ondergrens");
benchmarkTestInput.Length = GetCellValueAsDouble("B", "Trajectlengte") * 1000.0;
var assessmentGradeCategories = new List<AssessmentSectionCategory>();
for (int iRow = 4; iRow <= 8; iRow++)
{
var expectedAssessmentGrade = GetCellValueAsString("D", iRow).ToExpectedAssessmentGrade();
assessmentGradeCategories.Add(new AssessmentSectionCategory(
expectedAssessmentGrade.ToEAssessmentGrade(),
new Probability(GetCellValueAsDouble("F", iRow)),
new Probability(GetCellValueAsDouble("E", iRow))));
}
benchmarkTestInput.ExpectedAssessmentSectionCategories =
new CategoriesList<AssessmentSectionCategory>(assessmentGradeCategories);
var interpretationCategories = new List<InterpretationCategory>();
var lastKnownBoundary = new Probability(0);
for (int iRow = 13; iRow <= 19; iRow++)
{
var newBoundary = new Probability(GetCellValueAsDouble("E", iRow));
interpretationCategories.Add(new InterpretationCategory(
GetCellValueAsString("D", iRow).ToInterpretationCategory(),
lastKnownBoundary,
newBoundary));
lastKnownBoundary = newBoundary;
}
benchmarkTestInput.ExpectedInterpretationCategories =
new CategoriesList<InterpretationCategory>(interpretationCategories);
}
private static void TestProbabilisticFailureMechanismsResults(BenchmarkTestInput input,
BenchmarkTestResult result)
{
result.MethodResults.Wbi2B1 = false;
AssessmentSectionResult assemblerResult = null;
try
{
var assembler = new AssessmentGradeAssembler();
assemblerResult = assembler.AssembleAssessmentSectionWbi2B1(
input.ExpectedFailureMechanismsResults.Select(fmr => fmr.ExpectedCombinedProbability),
input.ExpectedAssessmentSectionCategories, false);
}
catch (AssemblyException)
{
Assert.IsTrue(input.ExpectedSafetyAssessmentAssemblyResult.ExpectedCombinedAssessmentGrade ==
EExpectedAssessmentGrade.Exception);
result.AreEqualAssemblyResultFinalVerdict = true;
result.AreEqualAssemblyResultFinalVerdictProbability = true;
result.MethodResults.Wbi2B1 = true;
return;
}
Assert.IsNotNull(assemblerResult);
AssertHelper.AssertAreEqualProbabilities(
input.ExpectedSafetyAssessmentAssemblyResult.ExpectedCombinedProbability,
new Probability(assemblerResult.FailureProbability));
Assert.AreEqual(
input.ExpectedSafetyAssessmentAssemblyResult.ExpectedCombinedAssessmentGrade.ToEAssessmentGrade(),
assemblerResult.Category);
result.AreEqualAssemblyResultFinalVerdict = true;
result.AreEqualAssemblyResultFinalVerdictProbability = true;
result.MethodResults.Wbi2B1 = true;
}
private static void TestGeneratedCombinedSections(BenchmarkTestInput input, BenchmarkTestResult result)
{
var assembler = new CommonFailureMechanismSectionAssembler();
// WBI-3A-1
var combinedSections = assembler.FindGreatestCommonDenominatorSectionsWbi3A1(
input.ExpectedFailureMechanismsResults.Select(
fm => new FailureMechanismSectionListWithFailureMechanismId(fm.Name,
fm.Sections.Select(
s => new FailureMechanismSection(s.Start, s.End))))
.ToArray()
, input.Length);
try
{
Assert.IsNotNull(combinedSections);
var expectedSections = input.ExpectedCombinedSectionResult.ToArray();
var calculatedSections = combinedSections.Sections.ToArray();
Assert.AreEqual(expectedSections.Length, calculatedSections.Length);
for (int i = 0; i < expectedSections.Length; i++)
{
Assert.AreEqual(expectedSections[i].SectionStart, calculatedSections[i].SectionStart, 0.01);
Assert.AreEqual(expectedSections[i].SectionEnd, calculatedSections[i].SectionEnd, 0.01);
}
result.AreEqualAssemblyResultCombinedSections = true;
result.MethodResults.Wbi3A1 = true;
}
catch (AssertionException)
{
result.AreEqualAssemblyResultCombinedSections = false;
result.MethodResults.Wbi3A1 = false;
}
}
/// <summary>
/// Reads all relevant input and expected output for a specific failure mechanism.
/// </summary>
/// <param name="benchmarkTestInput">The test input.</param>
/// <param name="mechanismId">String used to identify the failure mechanism.</param>
public void Read(BenchmarkTestInput benchmarkTestInput, string mechanismId)
{
bool hasLengthEffect = GetCellValueAsString("C", "Lengte-effect") == "Ja";
ExpectedFailureMechanismResult expectedFailureMechanismResult =
new ExpectedFailureMechanismResult(GetCellValueAsString("C", "Faalpad"), mechanismId, hasLengthEffect);
ReadGeneralInformation(expectedFailureMechanismResult);
ReadFailureMechanismSections(expectedFailureMechanismResult);
benchmarkTestInput.ExpectedFailureMechanismsResults.Add(expectedFailureMechanismResult);
}
/// <summary>
/// Reads the final verdict worksheet of a benchmark test definition.
/// </summary>
/// <param name="benchmarkTestInput">The test input.</param>
public void Read(BenchmarkTestInput benchmarkTestInput)
{
benchmarkTestInput.ExpectedSafetyAssessmentAssemblyResult.ExpectedCombinedProbability =
new Probability(GetCellValueAsDouble("D", "Overstromingskans traject"));
benchmarkTestInput.ExpectedSafetyAssessmentAssemblyResult.ExpectedCombinedProbabilityTemporal =
new Probability(GetCellValueAsDouble("D", "Overstromingskans traject (tussentijds)"));
benchmarkTestInput.ExpectedSafetyAssessmentAssemblyResult.ExpectedCombinedAssessmentGrade =
GetCellValueAsString("E", "Overstromingskans traject").ToExpectedAssessmentGrade();
benchmarkTestInput.ExpectedSafetyAssessmentAssemblyResult.ExpectedCombinedAssessmentGradeTemporal =
GetCellValueAsString("E", "Overstromingskans traject (tussentijds)").ToExpectedAssessmentGrade();
}
/// <summary>
/// Test the assembly of combined sections.
/// </summary>
/// <param name="input">The input.</param>
/// <param name="result">The result.</param>
public static void TestAssemblyOfCombinedSections(BenchmarkTestInput input, BenchmarkTestResult result)
{
TestGeneratedCombinedSections(input, result);
TestCombinedSectionsFinalResults(input, result);
TestCombinedSectionsFinalResultsTemporal(input, result);
foreach (FailureMechanismSectionListWithFailureMechanismId failureMechanismsCombinedResult in input
.ExpectedCombinedSectionResultPerFailureMechanism)
{
var mechanism = input.ExpectedFailureMechanismsResults.First(r => r.MechanismId == failureMechanismsCombinedResult.FailureMechanismId);
TestCombinedSectionsFailureMechanismResults(input, result, mechanism.Name, failureMechanismsCombinedResult.FailureMechanismId, mechanism.HasLengthEffect);
}
}
/// <summary>
/// Tests the interpretation categories.
/// </summary>
/// <param name="input">The input.</param>
/// <param name="result">The result.</param>
public static void TestEqualInterpretationCategories(BenchmarkTestInput input, BenchmarkTestResult result)
{
var calculator = new CategoryLimitsCalculator();
// WBI-2-1
CategoriesList <InterpretationCategory> categories = calculator.CalculateInterpretationCategoryLimitsWbi03(
new AssessmentSection((Probability)input.SignalingNorm, (Probability)input.LowerBoundaryNorm));
CategoriesList <InterpretationCategory> expectedCategories = input.ExpectedInterpretationCategories;
result.AreEqualCategoriesListInterpretationCategories =
AssertHelper.AssertEqualCategoriesList <InterpretationCategory, EInterpretationCategory>(
expectedCategories, categories);
result.MethodResults.Wbi03 = result.AreEqualCategoriesListInterpretationCategories;
}
public void ReaderReadsInformationCorrectly()
{
var testFile = Path.Combine(GetTestDir(), "Benchmarktool Excel assemblage - Gecombineerd vakoordeeel.xlsx");
using (SpreadsheetDocument spreadsheetDocument = SpreadsheetDocument.Open(testFile, false))
{
WorkbookPart workbookPart = spreadsheetDocument.WorkbookPart;
var workSheetParts = ReadWorkSheetParts(workbookPart);
var workSheetPart = workSheetParts["Gecombineerd vakoordeel"];
var reader = new CommonAssessmentSectionResultsReader(workSheetPart, workbookPart);
var result = new BenchmarkTestInput();
result.ExpectedFailureMechanismsResults.AddRange(new[]
{
new ExpectedFailureMechanismResult("Piping", "STPH", true),
new ExpectedFailureMechanismResult("Macrostabiliteit binnen", "STBI", true),
new ExpectedFailureMechanismResult("Graserosie kruin en binnentalud", "GEKB", true),
new ExpectedFailureMechanismResult("Duinafslag", "DA", true),
new ExpectedFailureMechanismResult("Kunstwerken puntconstructies", "STKWp", true),
new ExpectedFailureMechanismResult("Betrouwbaarheid sluiting kunstwerk", "BSKW", true),
new ExpectedFailureMechanismResult("Hoogte kunstwerk", "HTKW", true),
});
reader.Read(result);
Assert.AreEqual(104, result.ExpectedCombinedSectionResult.Count());
AssertResultsIsAsExpected(342.187662, 910, EInterpretationCategory.III, result.ExpectedCombinedSectionResult.ElementAt(9));
AssertResultsIsAsExpected(2519.652041, 3010, EInterpretationCategory.I, result.ExpectedCombinedSectionResult.ElementAt(18));
AssertResultsIsAsExpected(3010, 3313.767881, EInterpretationCategory.I, result.ExpectedCombinedSectionResult.ElementAt(19));
AssertResultsIsAsExpected(342.187662, 910, EInterpretationCategory.III, result.ExpectedCombinedSectionResultTemporal.ElementAt(9));
AssertResultsIsAsExpected(2519.652041, 3010, EInterpretationCategory.I, result.ExpectedCombinedSectionResultTemporal.ElementAt(18));
AssertResultsIsAsExpected(3010, 3313.767881, EInterpretationCategory.I, result.ExpectedCombinedSectionResultTemporal.ElementAt(19));
Assert.AreEqual(7, result.ExpectedCombinedSectionResultPerFailureMechanism.Count());
foreach (var failureMechanismSectionList in result.ExpectedCombinedSectionResultPerFailureMechanism)
{
Assert.AreEqual(104, failureMechanismSectionList.Sections.Count());
FailureMechanismSection ninethSection = failureMechanismSectionList.Sections.ElementAt(13);
var mechanismId = failureMechanismSectionList.FailureMechanismId;
if (ninethSection is FailureMechanismSectionWithCategory)
{
var sectionWithDirectCategory = (FailureMechanismSectionWithCategory)ninethSection;
AssertResultsIsAsExpected(1440, 1545.093896, expectedDirectResults[mechanismId], sectionWithDirectCategory);
}
}
}
}
/// <summary>
/// Reads the input and expected output of assembly of the combined section results.
/// </summary>
/// <param name="benchmarkTestInput">The input to set the results on.</param>
public void Read(BenchmarkTestInput benchmarkTestInput)
{
var commonSections = new List <FailureMechanismSectionWithCategory>();
var commonSectionsTemporal = new List <FailureMechanismSectionWithCategory>();
var failureMechanismSpecificCommonSectionsWithResults = new Dictionary <string, List <FailureMechanismSectionWithCategory> >();
foreach (var failureMechanismsKey in benchmarkTestInput.ExpectedFailureMechanismsResults.Select(r => r.MechanismId).ToArray())
{
failureMechanismSpecificCommonSectionsWithResults[failureMechanismsKey] = new List <FailureMechanismSectionWithCategory>();
}
var columnKeys = GetColumnKeys(2);
int iRow = 3;
while (iRow <= MaxRow)
{
var startMeters = GetCellValueAsDouble("B", iRow) * 1000.0;
var endMeters = GetCellValueAsDouble("C", iRow) * 1000.0;
if (double.IsNaN(startMeters) || double.IsNaN(endMeters))
{
break;
}
AddSectionToList(commonSections, "D", iRow, startMeters, endMeters);
AddSectionToList(commonSectionsTemporal, "E", iRow, startMeters, endMeters);
foreach (var keyValuePair in failureMechanismSpecificCommonSectionsWithResults)
{
AddSectionToList(keyValuePair.Value, columnKeys[keyValuePair.Key], iRow, startMeters, endMeters);
}
iRow++;
}
benchmarkTestInput.ExpectedCombinedSectionResult = commonSections;
benchmarkTestInput.ExpectedCombinedSectionResultTemporal = commonSectionsTemporal;
var resultsPerFailureMechanism = failureMechanismSpecificCommonSectionsWithResults.Select(kv => new FailureMechanismSectionListWithFailureMechanismId(kv.Key, kv.Value));
benchmarkTestInput.ExpectedCombinedSectionResultPerFailureMechanism = resultsPerFailureMechanism;
}
public void RunBenchmarkTest(string testName, string fileName)
{
BenchmarkTestInput input = AssemblyExcelFileReader.Read(fileName, testName);
BenchmarkTestResult testResult = new BenchmarkTestResult(fileName, testName);
BenchmarkTestRunner.TestEqualNormCategories(input, testResult);
BenchmarkTestRunner.TestEqualInterpretationCategories(input, testResult);
foreach (ExpectedFailureMechanismResult expectedFailureMechanismResult in input.ExpectedFailureMechanismsResults)
{
BenchmarkTestRunner.TestFailureMechanismAssembly(expectedFailureMechanismResult, testResult,
input.ExpectedInterpretationCategories);
}
BenchmarkTestRunner.TestFinalVerdictAssembly(input, testResult);
BenchmarkTestRunner.TestAssemblyOfCombinedSections(input, testResult);
testResults[testName] = testResult;
}
private static void TestCombinedSectionsFailureMechanismResults(BenchmarkTestInput input,
BenchmarkTestResult result, string mechanismName, string mechanismId, bool hasLengthEffect)
{
var assembler = new CommonFailureMechanismSectionAssembler();
var combinedSections = new FailureMechanismSectionList(input.ExpectedCombinedSectionResult);
var failureMechanismSectionList = new FailureMechanismSectionList(
input.ExpectedFailureMechanismsResults.First(fm => fm.MechanismId == mechanismId).Sections
.OfType <ExpectedFailureMechanismSection>()
.Select(CreateExpectedFailureMechanismSectionWithResult));
var calculatedSectionResults = assembler.TranslateFailureMechanismResultsToCommonSectionsWbi3B1(
failureMechanismSectionList,
combinedSections);
var calculatedSections = calculatedSectionResults.Sections.OfType <FailureMechanismSectionWithCategory>().ToArray();
var expectedSections = input.ExpectedCombinedSectionResultPerFailureMechanism.First(l => l.FailureMechanismId == mechanismId).Sections
.OfType <FailureMechanismSectionWithCategory>().ToArray();
var failureMechanismResult = GetBenchmarkTestFailureMechanismResult(result, mechanismName, mechanismId, hasLengthEffect);
try
{
Assert.AreEqual(expectedSections.Length, calculatedSections.Length);
for (int i = 0; i < expectedSections.Length; i++)
{
Assert.AreEqual(expectedSections[i].SectionStart, calculatedSections[i].SectionStart, 0.01);
Assert.AreEqual(expectedSections[i].SectionEnd, calculatedSections[i].SectionEnd, 0.01);
Assert.AreEqual(expectedSections[i].Category, calculatedSections[i].Category);
}
failureMechanismResult.AreEqualCombinedResultsCombinedSections = true;
result.MethodResults.Wbi3B1 = BenchmarkTestHelper.GetUpdatedMethodResult(result.MethodResults.Wbi3B1, true);
}
catch (AssertionException e)
{
Console.WriteLine("Error matching combined sections for {0}: {1}", failureMechanismResult.Name, e.Message);
failureMechanismResult.AreEqualCombinedResultsCombinedSections = false;
result.MethodResults.Wbi3B1 = false;
}
}
public void ReaderReadsInformationCorrectly()
{
var testFile = Path.Combine(GetTestDir(), "Benchmarktool Excel assemblagetool - General information.xlsx");
using (SpreadsheetDocument spreadsheetDocument = SpreadsheetDocument.Open(testFile, false))
{
WorkbookPart workbookPart = spreadsheetDocument.WorkbookPart;
WorksheetPart workSheetPart = workbookPart.WorksheetParts.First();
var reader = new GeneralInformationReader(workSheetPart, workbookPart);
var result = new BenchmarkTestInput();
reader.Read(result);
Assert.AreEqual(1 / 3000.0, result.SignalingNorm, 1e-8);
Assert.AreEqual(1 / 1000.0, result.LowerBoundaryNorm, 1e-8);
Assert.AreEqual(10400, result.Length, 1e-8);
var assessmentGradeCategories = result.ExpectedAssessmentSectionCategories.Categories;
Assert.AreEqual(5, assessmentGradeCategories.Length);
AssertAreEqualGradeCategories(EAssessmentGrade.APlus, 0.0, result.SignalingNorm / 30.0, assessmentGradeCategories[0]);
AssertAreEqualGradeCategories(EAssessmentGrade.A, result.SignalingNorm / 30.0, result.SignalingNorm, assessmentGradeCategories[1]);
AssertAreEqualGradeCategories(EAssessmentGrade.B, result.SignalingNorm, result.LowerBoundaryNorm, assessmentGradeCategories[2]);
AssertAreEqualGradeCategories(EAssessmentGrade.C, result.LowerBoundaryNorm, result.LowerBoundaryNorm * 30.0, assessmentGradeCategories[3]);
AssertAreEqualGradeCategories(EAssessmentGrade.D, result.LowerBoundaryNorm * 30.0, 1.0, assessmentGradeCategories[4]);
var interpretationCategories = result.ExpectedInterpretationCategories.Categories;
Assert.AreEqual(7, interpretationCategories.Length);
AssertAreEqualInterpretationCategories(EInterpretationCategory.III, 0.0, result.SignalingNorm / 1000.0, interpretationCategories[0]);
AssertAreEqualInterpretationCategories(EInterpretationCategory.II, result.SignalingNorm / 1000.0, result.SignalingNorm / 100.0, interpretationCategories[1]);
AssertAreEqualInterpretationCategories(EInterpretationCategory.I, result.SignalingNorm / 100.0, result.SignalingNorm / 10.0, interpretationCategories[2]);
AssertAreEqualInterpretationCategories(EInterpretationCategory.Zero, result.SignalingNorm / 10.0, result.SignalingNorm, interpretationCategories[3]);
AssertAreEqualInterpretationCategories(EInterpretationCategory.IMin, result.SignalingNorm, result.LowerBoundaryNorm, interpretationCategories[4]);
AssertAreEqualInterpretationCategories(EInterpretationCategory.IIMin, result.LowerBoundaryNorm, result.LowerBoundaryNorm * 10.0, interpretationCategories[5]);
AssertAreEqualInterpretationCategories(EInterpretationCategory.IIIMin, result.LowerBoundaryNorm * 10.0, 1.0, interpretationCategories[6]);
}
}
public void ReaderReadsInformationCorrectly()
{
var testFile = Path.Combine(GetTestDir(), "Benchmarktool assemblage - Veiligheidsoordeel.xlsx");
using (SpreadsheetDocument spreadsheetDocument = SpreadsheetDocument.Open(testFile, false))
{
WorkbookPart workbookPart = spreadsheetDocument.WorkbookPart;
var workSheetParts = ReadWorkSheetParts(workbookPart);
var workSheetPart = workSheetParts["Veiligheidsoordeel"];
var reader = new SafetyAssessmentFinalResultReader(workSheetPart, workbookPart);
var result = new BenchmarkTestInput();
reader.Read(result);
var assemblyResult = result.ExpectedSafetyAssessmentAssemblyResult;
Assert.AreEqual(0.64, assemblyResult.ExpectedCombinedProbability, 1e-2);
Assert.AreEqual(0.64, assemblyResult.ExpectedCombinedProbabilityTemporal, 1e-2);
Assert.AreEqual(EExpectedAssessmentGrade.APlus, assemblyResult.ExpectedCombinedAssessmentGrade);
Assert.AreEqual(EExpectedAssessmentGrade.APlus, assemblyResult.ExpectedCombinedAssessmentGradeTemporal);
}
}
/// <summary>
/// Creates a new instance of <see cref="BenchmarkTestInput"/>.
/// </summary>
/// <param name="excelFileName">The name of the excel file.</param>
/// <param name="testName">The test name.</param>
/// <returns>A <see cref="BenchmarkTestInput"/>.</returns>
public static BenchmarkTestInput Read(string excelFileName, string testName)
{
if (!File.Exists(excelFileName))
{
return(null);
}
var benchmarkTestInput = new BenchmarkTestInput
{
FileName = excelFileName,
TestName = testName
};
using (SpreadsheetDocument spreadsheetDocument = SpreadsheetDocument.Open(excelFileName, false))
{
WorkbookPart workbookPart = spreadsheetDocument.WorkbookPart;
var workSheetParts = ExcelReaderHelper.ReadWorkSheetParts(workbookPart);
ReadGeneralAssessmentSectionInformation(workSheetParts["Normen en duidingsklassen"], workbookPart, benchmarkTestInput);
var tabsToIgnore = new[]
{
"Informatiepagina", "Normen en duidingsklassen", "Veiligheidsoordeel", "Gecombineerd vakoordeel"
};
var failureMechanismsTabs = workSheetParts.Select(wsp => wsp.Key).Except(tabsToIgnore).ToArray();
foreach (var failureMechanismsTab in failureMechanismsTabs)
{
ReadFailureMechanism(failureMechanismsTab, workSheetParts[failureMechanismsTab], workbookPart, benchmarkTestInput);
}
ReadSafetyAssessmentFinalResult(workSheetParts["Veiligheidsoordeel"], workbookPart, benchmarkTestInput);
ReadCombinedAssessmentSectionResults(workSheetParts["Gecombineerd vakoordeel"], workbookPart, benchmarkTestInput);
return(benchmarkTestInput);
}
}
public void RunBenchmarkTest()
{
var testDirectory = Path.Combine(BenchmarkTestHelper.GetBenchmarkTestsDirectory(), "testdefinitions");
var fileName = Directory.GetFiles(testDirectory, "*traject 30-4*.xlsx").First();
var testName = BenchmarkTestHelper.GetTestName(fileName);
BenchmarkTestInput input = AssemblyExcelFileReader.Read(fileName, testName);
BenchmarkTestResult testResult = new BenchmarkTestResult(fileName, testName);
BenchmarkTestRunner.TestEqualNormCategories(input, testResult);
BenchmarkTestRunner.TestEqualInterpretationCategories(input, testResult);
foreach (ExpectedFailureMechanismResult expectedFailureMechanismResult in input
.ExpectedFailureMechanismsResults)
{
BenchmarkTestRunner.TestFailureMechanismAssembly(expectedFailureMechanismResult,
testResult,
input.ExpectedInterpretationCategories);
}
BenchmarkTestRunner.TestFinalVerdictAssembly(input, testResult);
BenchmarkTestRunner.TestAssemblyOfCombinedSections(input, testResult);
}
private static void ReadCombinedAssessmentSectionResults(WorksheetPart worksheetPart,
WorkbookPart workbookPart, BenchmarkTestInput benchmarkTestInput)
{
new CommonAssessmentSectionResultsReader(worksheetPart, workbookPart).Read(benchmarkTestInput);
}
private static void ReadSafetyAssessmentFinalResult(WorksheetPart worksheetPart, WorkbookPart workbookPart,
BenchmarkTestInput benchmarkTestInput)
{
new SafetyAssessmentFinalResultReader(worksheetPart, workbookPart).Read(benchmarkTestInput);
}
private static void ReadGeneralAssessmentSectionInformation(WorksheetPart workSheetPart,
WorkbookPart workbookPart,
BenchmarkTestInput benchmarkTestInput)
{
new GeneralInformationReader(workSheetPart, workbookPart).Read(benchmarkTestInput);
}
private static void ReadFailureMechanism(string mechanismId, WorksheetPart worksheetPart,
WorkbookPart workbookPart, BenchmarkTestInput benchmarkTestInput)
{
new FailureMechanismsReader(worksheetPart, workbookPart).Read(benchmarkTestInput, mechanismId);
}
/// <summary>
/// Test the final verdict assembly.
/// </summary>
/// <param name="input">The input.</param>
/// <param name="result">The result.</param>
public static void TestFinalVerdictAssembly(BenchmarkTestInput input, BenchmarkTestResult result)
{
TestProbabilisticFailureMechanismsResults(input, result);
TestProbabilisticFailureMechanismsResultsTemporal(input, result);
}
