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;
}
}
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;
}
}
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 string ReplaceCategoriesKeywordsWithResult(string template, BenchmarkTestResult result)
{
template = template.Replace("$AreEqualCategoriesListAssessmentSection$",
ToResultText(result.AreEqualCategoriesListAssessmentSection));
template = template.Replace("$AreEqualCategoriesListInterpretationCategories$",
ToResultText(result.AreEqualCategoriesListInterpretationCategories));
return(template);
}
private static string ReplaceFinalVerdictKeywordsWithResult(string template, BenchmarkTestResult result)
{
template = template.Replace("$AreEqualAssemblyResultFinalVerdict$",
ToResultText(result.AreEqualAssemblyResultFinalVerdict));
template = template.Replace("$AreEqualAssemblyResultFinalVerdictProbability$",
ToResultText(result.AreEqualAssemblyResultFinalVerdictProbability));
template = template.Replace("$AreEqualAssemblyResultFinalVerdictProbabilityTemporal$",
ToResultText(result.AreEqualAssemblyResultFinalVerdictProbabilityTemporal));
template = template.Replace("$AreEqualAssemblyResultFinalVerdictTemporal$",
ToResultText(result.AreEqualAssemblyResultFinalVerdictTemporal));
return(template);
}
/// <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>
/// Writes the report.
/// </summary>
/// <param name="order">The order.</param>
/// <param name="result">The result.</param>
/// <param name="reportDirectory">The report directory.</param>
public static void WriteReport(int order, BenchmarkTestResult result, string reportDirectory)
{
string template = GetReportTemplate();
template = template.Replace("$BenchmarkTestName$", result.TestName.Replace("_", @"\_"));
template = template.Replace("$Order$", order.ToString());
template = ReplaceFailureMechanismsTableWithResult(template, result);
template = ReplaceCategoriesKeywordsWithResult(template, result);
template = ReplaceFinalVerdictKeywordsWithResult(template, result);
template = ReplaceCommonSectionsKeywordsWithResult(template, result);
WriteReportToDestination(template, reportDirectory, GetTargetFileNameFromInputName(result.FileName));
}
/// <summary>
/// Tests the norm categories.
/// </summary>
/// <param name="input">The input.</param>
/// <param name="result">The result.</param>
public static void TestEqualNormCategories(BenchmarkTestInput input, BenchmarkTestResult result)
{
var calculator = new CategoryLimitsCalculator();
// WBI-2-1
CategoriesList <AssessmentSectionCategory> categories = calculator.CalculateAssessmentSectionCategoryLimitsWbi21(
new AssessmentSection((Probability)input.SignalingNorm, (Probability)input.LowerBoundaryNorm));
CategoriesList <AssessmentSectionCategory> expectedCategories =
input.ExpectedAssessmentSectionCategories;
result.AreEqualCategoriesListAssessmentSection =
AssertHelper.AssertEqualCategoriesList <AssessmentSectionCategory, EAssessmentGrade>(
expectedCategories, categories);
result.MethodResults.Wbi21 = result.AreEqualCategoriesListAssessmentSection;
}
private static BenchmarkFailureMechanismTestResult GetBenchmarkTestFailureMechanismResult(
BenchmarkTestResult result,
string mechanismName, string mechanismId, bool hasLengthEffect)
{
var failureMechanismTestResult = result.FailureMechanismResults.FirstOrDefault(fmr => fmr.MechanismId == mechanismId);
if (failureMechanismTestResult == null)
{
failureMechanismTestResult =
BenchmarkTestFailureMechanismResultFactory.CreateFailureMechanismTestResult(mechanismName, mechanismId, hasLengthEffect);
result.FailureMechanismResults.Add(failureMechanismTestResult);
}
return(failureMechanismTestResult);
}
/// <summary>
/// Test the failure mechanism assembly.
/// </summary>
/// <param name="expectedFailureMechanismResult">The expected failure mechanism result.</param>
/// <param name="testResult">The test result.</param>
/// <param name="interpretationCategories">The interpretation categories needed to translate a probability to an interpretation category.</param>
public static void TestFailureMechanismAssembly(ExpectedFailureMechanismResult expectedFailureMechanismResult,
BenchmarkTestResult testResult, CategoriesList <InterpretationCategory> interpretationCategories)
{
var failureMechanismTestResult =
GetBenchmarkTestFailureMechanismResult(testResult, expectedFailureMechanismResult.Name, expectedFailureMechanismResult.MechanismId, expectedFailureMechanismResult.HasLengthEffect);
var failureMechanismTester =
expectedFailureMechanismResult.HasLengthEffect
? new FailureMechanismWithLengthEffectResultTester(testResult.MethodResults, expectedFailureMechanismResult, interpretationCategories) as IFailureMechanismResultTester
: new FailureMechanismResultTester(testResult.MethodResults, expectedFailureMechanismResult, interpretationCategories);
failureMechanismTestResult.AreEqualCombinedAssessmentResultsPerSection =
failureMechanismTester.TestCombinedAssessment();
failureMechanismTestResult.AreEqualAssessmentResultPerAssessmentSection =
failureMechanismTester.TestAssessmentSectionResult();
failureMechanismTestResult.AreEqualAssessmentResultPerAssessmentSectionTemporal =
failureMechanismTester.TestAssessmentSectionResultTemporal();
}
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 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 string ReplaceCommonSectionsKeywordsWithResult(string template, BenchmarkTestResult result)
{
template = template.Replace("$AreEqualAssemblyResultCombinedSections$",
ToResultText(result.AreEqualAssemblyResultCombinedSections));
template = template.Replace("$AreEqualAssemblyResultCombinedSectionsResults$",
ToResultText(result.AreEqualAssemblyResultCombinedSectionsResults));
template = template.Replace("$AreEqualAssemblyResultCombinedSectionsResultsTemporal$",
ToResultText(result.AreEqualAssemblyResultCombinedSectionsResultsTemporal));
return(template);
}
private static string ReplaceFailureMechanismsTableWithResult(string template, BenchmarkTestResult result)
{
var str = "";
for (var index = 0; index < result.FailureMechanismResults.Count; index++)
{
var m = result.FailureMechanismResults[index];
str += m.Name + " & " + m.MechanismId + " & " + m.HasLengthEffect + " & " +
ToResultText(m.AreEqualCombinedAssessmentResultsPerSection) + " & " +
ToResultText(m.AreEqualAssessmentResultPerAssessmentSection) + " & " +
ToResultText(m.AreEqualAssessmentResultPerAssessmentSectionTemporal) + " & " +
ToResultText(m.AreEqualCombinedResultsCombinedSections);
if (index != result.FailureMechanismResults.Count - 1)
{
str += @" \B \\ \T" + "\n";
}
}
return(template.Replace("$FailureMechanismResultsTable$", str));
}
/// <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);
}
