public void AssembleCombinedFailureMechanismSections_KernelWithInvalidOutput_ThrowsAssessmentSectionAssemblyCalculatorException()
{
// Setup
var random = new Random(21);
using (new AssemblyToolKernelFactoryConfig())
{
var factory = (TestAssemblyToolKernelFactory)AssemblyToolKernelFactory.Instance;
CombinedFailureMechanismSectionAssemblyKernelStub kernel = factory.LastCreatedCombinedFailureMechanismSectionAssemblyKernel;
kernel.FailureMechanismResult = new FailureMechanismSectionList(new[]
{
new FailureMechanismSectionWithCategory(0, 1, (EInterpretationCategory)99)
});
var calculator = new AssessmentSectionAssemblyCalculator(factory);
// Call
void Call() => calculator.AssembleCombinedFailureMechanismSections(new[]
{
new[]
{
new CombinedAssemblyFailureMechanismSection(0, 1, random.NextEnumValue <FailureMechanismSectionAssemblyGroup>())
}
}, random.NextDouble());
// Assert
var exception = Assert.Throws <AssessmentSectionAssemblyCalculatorException>(Call);
Assert.IsInstanceOf <InvalidEnumArgumentException>(exception.InnerException);
Assert.AreEqual(AssemblyErrorMessageCreator.CreateGenericErrorMessage(), exception.Message);
}
}
public void AssembleCombinedFailureMechanismSections_KernelThrowsAssemblyException_ThrowsAssessmentSectionAssemblyCalculatorException()
{
// Setup
var random = new Random(21);
using (new AssemblyToolKernelFactoryConfig())
{
var factory = (TestAssemblyToolKernelFactory)AssemblyToolKernelFactory.Instance;
CombinedFailureMechanismSectionAssemblyKernelStub kernel = factory.LastCreatedCombinedFailureMechanismSectionAssemblyKernel;
kernel.ThrowAssemblyExceptionOnCalculate = true;
var calculator = new AssessmentSectionAssemblyCalculator(factory);
// Call
void Call() =>
calculator.AssembleCombinedFailureMechanismSections(new[]
{
new[]
{
new CombinedAssemblyFailureMechanismSection(0, 1, random.NextEnumValue <FailureMechanismSectionAssemblyGroup>())
}
}, random.NextDouble());
// Assert
var exception = Assert.Throws <AssessmentSectionAssemblyCalculatorException>(Call);
Assert.IsInstanceOf <AssemblyException>(exception.InnerException);
Assert.AreEqual(AssemblyErrorMessageCreator.CreateErrorMessage(new[]
{
AssemblyErrorMessageTestHelper.Create(string.Empty, EAssemblyErrors.EmptyResultsList)
}), exception.Message);
}
}
public void AssembleCombinedFailureMechanismSections_WithInvalidInput_ThrowsAssessmentSectionAssemblyCalculatorException()
{
// Setup
var random = new Random(21);
using (new AssemblyToolKernelFactoryConfig())
{
var factory = (TestAssemblyToolKernelFactory)AssemblyToolKernelFactory.Instance;
var calculator = new AssessmentSectionAssemblyCalculator(factory);
// Call
void Call() =>
calculator.AssembleCombinedFailureMechanismSections(new[]
{
new[]
{
new CombinedAssemblyFailureMechanismSection(0, 1, (FailureMechanismSectionAssemblyGroup)99)
}
}, random.Next());
// Assert
var exception = Assert.Throws <AssessmentSectionAssemblyCalculatorException>(Call);
Assert.IsInstanceOf <Exception>(exception.InnerException);
Assert.AreEqual(AssemblyErrorMessageCreator.CreateGenericErrorMessage(), exception.Message);
}
}
public void AssembleCombinedFailureMechanismSections_KernelWithCompleteOutput_OutputCorrectlyReturnedByCalculator()
{
// Setup
var random = new Random(39);
using (new AssemblyToolKernelFactoryConfig())
{
var factory = (TestAssemblyToolKernelFactory)AssemblyToolKernelFactory.Instance;
var calculator = new AssessmentSectionAssemblyCalculator(factory);
// Call
CombinedFailureMechanismSectionAssemblyResultWrapper output = calculator.AssembleCombinedFailureMechanismSections(new[]
{
new[]
{
new CombinedAssemblyFailureMechanismSection(0, 1, random.NextEnumValue <FailureMechanismSectionAssemblyGroup>())
}
}, random.NextDouble());
// Assert
CombinedFailureMechanismSectionAssemblyKernelStub kernel = factory.LastCreatedCombinedFailureMechanismSectionAssemblyKernel;
CombinedFailureMechanismSectionAssemblyAssert.AssertAssembly(new[]
{
kernel.FailureMechanismResult
}, kernel.CombinedSectionResults, output.AssemblyResults);
Assert.AreEqual(AssemblyMethod.BOI3A1, output.CommonSectionAssemblyMethod);
Assert.AreEqual(AssemblyMethod.BOI3B1, output.FailureMechanismResultsAssemblyMethod);
Assert.AreEqual(AssemblyMethod.BOI3C1, output.CombinedSectionResultAssemblyMethod);
}
}
public void AssembleAssessmentSection_KernelThrowsAssemblyException_ThrowsAssessmentSectionAssemblyCalculatorException()
{
// Setup
var random = new Random(21);
double signalFloodingProbability = random.NextDouble();
double maximumAllowableFloodingProbability = signalFloodingProbability + 1e-3;
using (new AssemblyToolKernelFactoryConfig())
{
var factory = (TestAssemblyToolKernelFactory)AssemblyToolKernelFactory.Instance;
AssessmentSectionAssemblyKernelStub kernel = factory.LastCreatedAssessmentSectionAssemblyKernel;
kernel.ThrowAssemblyExceptionOnCalculate = true;
var calculator = new AssessmentSectionAssemblyCalculator(factory);
// Call
void Call() => calculator.AssembleAssessmentSection(Enumerable.Empty <double>(), maximumAllowableFloodingProbability, signalFloodingProbability);
// Assert
var exception = Assert.Throws <AssessmentSectionAssemblyCalculatorException>(Call);
Assert.IsInstanceOf <AssemblyException>(exception.InnerException);
Assert.AreEqual(AssemblyErrorMessageCreator.CreateErrorMessage(new[]
{
AssemblyErrorMessageTestHelper.Create(string.Empty, EAssemblyErrors.InvalidCategoryLimits)
}), exception.Message);
}
}
public void AssembleAssessmentSection_KernelWithInvalidOutput_ThrowsAssessmentSectionAssemblyCalculatorException()
{
// Setup
var random = new Random(21);
double signalFloodingProbability = random.NextDouble();
double maximumAllowableFloodingProbability = signalFloodingProbability + 1e-3;
using (new AssemblyToolKernelFactoryConfig())
{
var factory = (TestAssemblyToolKernelFactory)AssemblyToolKernelFactory.Instance;
AssessmentSectionAssemblyKernelStub kernel = factory.LastCreatedAssessmentSectionAssemblyKernel;
kernel.AssemblyProbability = new Probability(random.NextDouble());
kernel.AssemblyGroup = (EAssessmentGrade)99;
var calculator = new AssessmentSectionAssemblyCalculator(factory);
// Call
void Call() => calculator.AssembleAssessmentSection(Enumerable.Empty <double>(), maximumAllowableFloodingProbability, signalFloodingProbability);
// Assert
var exception = Assert.Throws <AssessmentSectionAssemblyCalculatorException>(Call);
Assert.IsInstanceOf <InvalidEnumArgumentException>(exception.InnerException);
Assert.AreEqual(AssemblyErrorMessageCreator.CreateGenericErrorMessage(), exception.Message);
}
}
public void AssembleAssessmentSection_KernelWithCompleteOutput_OutputCorrectlyReturnedByCalculator()
{
// Setup
var random = new Random(21);
double signalFloodingProbability = random.NextDouble();
double maximumAllowableFloodingProbability = signalFloodingProbability + 1e-3;
using (new AssemblyToolKernelFactoryConfig())
{
var factory = (TestAssemblyToolKernelFactory)AssemblyToolKernelFactory.Instance;
AssessmentSectionAssemblyKernelStub kernel = factory.LastCreatedAssessmentSectionAssemblyKernel;
var assemblyProbability = new Probability(random.NextDouble());
var assemblyGroup = random.NextEnumValue <EAssessmentGrade>();
kernel.AssemblyProbability = assemblyProbability;
kernel.AssemblyGroup = assemblyGroup;
var calculator = new AssessmentSectionAssemblyCalculator(factory);
// Call
AssessmentSectionAssemblyResultWrapper resultWrapper = calculator.AssembleAssessmentSection(
Enumerable.Empty <double>(), maximumAllowableFloodingProbability, signalFloodingProbability);
// Assert
AssessmentSectionAssemblyResult result = resultWrapper.AssemblyResult;
Assert.AreEqual(assemblyProbability, result.Probability);
Assert.AreEqual(AssessmentSectionAssemblyGroupCreator.CreateAssessmentSectionAssemblyGroup(assemblyGroup),
result.AssemblyGroup);
Assert.AreEqual(AssemblyMethod.BOI2A1, resultWrapper.ProbabilityMethod);
Assert.AreEqual(AssemblyMethod.BOI2B1, resultWrapper.AssemblyGroupMethod);
}
}
public void AssembleAssessmentSection_WithValidInput_InputCorrectlySetToKernel()
{
// Setup
var random = new Random(21);
double signalFloodingProbability = random.NextDouble();
double maximumAllowableFloodingProbability = signalFloodingProbability + 1e-3;
int nrOfProbabilities = random.Next(1, 10);
IEnumerable <double> failureMechanismProbabilities = Enumerable.Repeat(random.NextDouble(), nrOfProbabilities)
.ToArray();
using (new AssemblyToolKernelFactoryConfig())
{
var factory = (TestAssemblyToolKernelFactory)AssemblyToolKernelFactory.Instance;
var assessmentSectionCategories = new CategoriesList <AssessmentSectionCategory>(new[]
{
new AssessmentSectionCategory(random.NextEnumValue <EAssessmentGrade>(), new Probability(0), new Probability(1))
});
AssemblyCategoryLimitsKernelStub categoryLimitsKernel = factory.LastCreatedAssemblyCategoryLimitsKernel;
categoryLimitsKernel.AssessmentSectionCategoryLimits = assessmentSectionCategories;
AssessmentSectionAssemblyKernelStub assessmentSectionAssemblyKernel = factory.LastCreatedAssessmentSectionAssemblyKernel;
var assemblyProbability = new Probability(random.NextDouble());
assessmentSectionAssemblyKernel.AssemblyProbability = assemblyProbability;
assessmentSectionAssemblyKernel.AssemblyGroup = random.NextEnumValue <EAssessmentGrade>();
var calculator = new AssessmentSectionAssemblyCalculator(factory);
// Call
calculator.AssembleAssessmentSection(failureMechanismProbabilities, maximumAllowableFloodingProbability, signalFloodingProbability);
// Assert
Assert.IsTrue(categoryLimitsKernel.Calculated);
ProbabilityAssert.AreEqual(maximumAllowableFloodingProbability, categoryLimitsKernel.AssessmentSection.MaximumAllowableFloodingProbability);
ProbabilityAssert.AreEqual(signalFloodingProbability, categoryLimitsKernel.AssessmentSection.SignalFloodingProbability);
Assert.IsTrue(assessmentSectionAssemblyKernel.ProbabilityCalculated);
Assert.IsTrue(assessmentSectionAssemblyKernel.AssemblyGroupCalculated);
Assert.IsFalse(assessmentSectionAssemblyKernel.PartialAssembly);
Assert.AreSame(assessmentSectionCategories, assessmentSectionAssemblyKernel.Categories);
IEnumerable <Probability> actualProbabilitiesInput = assessmentSectionAssemblyKernel.FailureMechanismProbabilities;
Assert.AreEqual(nrOfProbabilities, actualProbabilitiesInput.Count());
for (var i = 0; i < nrOfProbabilities; i++)
{
ProbabilityAssert.AreEqual(failureMechanismProbabilities.ElementAt(i),
actualProbabilitiesInput.ElementAt(i));
}
Assert.AreEqual(assemblyProbability, assessmentSectionAssemblyKernel.AssemblyProbabilityInput);
}
}
public void Constructor_WithFactory_ExpectedValues()
{
// Setup
var mocks = new MockRepository();
var kernelFactory = mocks.Stub <IAssemblyToolKernelFactory>();
mocks.ReplayAll();
// Call
var calculator = new AssessmentSectionAssemblyCalculator(kernelFactory);
// Assert
Assert.IsInstanceOf <IAssessmentSectionAssemblyCalculator>(calculator);
mocks.VerifyAll();
}
public void AssembleCombinedFailureMechanismSections_InputNull_ThrowsArgumentNullException()
{
// Setup
var mocks = new MockRepository();
var kernelFactory = mocks.Stub <IAssemblyToolKernelFactory>();
mocks.ReplayAll();
var calculator = new AssessmentSectionAssemblyCalculator(kernelFactory);
// Call
void Call() => calculator.AssembleCombinedFailureMechanismSections(null, double.NaN);
// Assert
var exception = Assert.Throws <ArgumentNullException>(Call);
Assert.AreEqual("input", exception.ParamName);
}
public void AssembleAssessmentSection_FailureMechanismProbabilitiesNull_ThrowsArgumentNullException()
{
// Setup
var mocks = new MockRepository();
var kernelFactory = mocks.Stub <IAssemblyToolKernelFactory>();
mocks.ReplayAll();
var random = new Random(21);
var calculator = new AssessmentSectionAssemblyCalculator(kernelFactory);
// Call
void Call() => calculator.AssembleAssessmentSection(null, random.NextDouble(), random.NextDouble());
// Assert
var exception = Assert.Throws <ArgumentNullException>(Call);
Assert.AreEqual("failureMechanismProbabilities", exception.ParamName);
}
public void AssembleCombinedFailureMechanismSections_WithValidInput_InputCorrectlySetToKernel()
{
// Setup
var random = new Random(39);
var input = new[]
{
new[]
{
new CombinedAssemblyFailureMechanismSection(0, 1, random.NextEnumValue <FailureMechanismSectionAssemblyGroup>())
}
};
double assessmentSectionLength = random.NextDouble();
using (new AssemblyToolKernelFactoryConfig())
{
var factory = (TestAssemblyToolKernelFactory)AssemblyToolKernelFactory.Instance;
CombinedFailureMechanismSectionAssemblyKernelStub kernel = factory.LastCreatedCombinedFailureMechanismSectionAssemblyKernel;
var calculator = new AssessmentSectionAssemblyCalculator(factory);
// Call
calculator.AssembleCombinedFailureMechanismSections(input, assessmentSectionLength);
// Assert
CombinedFailureMechanismSectionsInputAssert.AssertCombinedFailureMechanismInput(input, kernel.FailureMechanismSectionLists);
Assert.AreEqual(assessmentSectionLength, kernel.AssessmentSectionLength);
Assert.IsTrue(kernel.CalculatedCommonSections);
Assert.AreSame(kernel.FailureMechanismSectionLists.Single(), kernel.FailureMechanismSectionList);
Assert.AreSame(kernel.CommonSections, kernel.CommonSectionsInput);
Assert.IsTrue(kernel.CalculatedCommonSectionResults);
Assert.AreEqual(1, kernel.FailureMechanismResultsInput.Count());
Assert.AreSame(kernel.FailureMechanismResult, kernel.FailureMechanismResultsInput.First());
Assert.IsFalse(kernel.PartialAssembly);
Assert.IsTrue(kernel.CalculatedSectionResults);
}
}
