public void AssembleFailureMechanism_CalculatorRan_ReturnsExpectedOutput()
{
// Setup
var failureMechanism = new WaveImpactAsphaltCoverFailureMechanism
{
AssemblyResult =
{
ProbabilityResultType = FailureMechanismAssemblyProbabilityResultType.Automatic
}
};
var assessmentSection = new AssessmentSectionStub();
using (new AssemblyToolCalculatorFactoryConfig())
{
var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance;
FailureMechanismAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator;
// Call
FailureMechanismAssemblyResultWrapper result = WaveImpactAsphaltCoverFailureMechanismAssemblyFactory.AssembleFailureMechanism(failureMechanism, assessmentSection);
// Assert
Assert.AreSame(calculator.AssemblyResultOutput, result);
}
}
public void AssembleFailureMechanism_CalculatorThrowsException_ThrowsAssemblyException()
{
// Setup
var failureMechanism = new WaveImpactAsphaltCoverFailureMechanism
{
AssemblyResult =
{
ProbabilityResultType = FailureMechanismAssemblyProbabilityResultType.Automatic
}
};
var assessmentSection = new AssessmentSectionStub();
using (new AssemblyToolCalculatorFactoryConfig())
{
var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance;
FailureMechanismAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator;
calculator.ThrowExceptionOnCalculate = true;
// Call
void Call() => WaveImpactAsphaltCoverFailureMechanismAssemblyFactory.AssembleFailureMechanism(failureMechanism, assessmentSection);
// Assert
var exception = Assert.Throws <AssemblyException>(Call);
Exception innerException = exception.InnerException;
Assert.IsInstanceOf <FailureMechanismAssemblyCalculatorException>(innerException);
Assert.AreEqual(innerException.Message, exception.Message);
}
}
public void AssembleSection_CalculatorThrowsException_ThrowsAssemblyException()
{
// Setup
FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
var sectionResult = new NonAdoptableWithProfileProbabilityFailureMechanismSectionResult(section);
var failureMechanism = new WaveImpactAsphaltCoverFailureMechanism();
var assessmentSection = new AssessmentSectionStub();
using (new AssemblyToolCalculatorFactoryConfig())
{
var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance;
FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator;
calculator.ThrowExceptionOnCalculate = true;
// Call
void Call() => WaveImpactAsphaltCoverFailureMechanismAssemblyFactory.AssembleSection(
sectionResult, failureMechanism, assessmentSection);
// Assert
var exception = Assert.Throws <AssemblyException>(Call);
Exception innerException = exception.InnerException;
Assert.IsInstanceOf <FailureMechanismSectionAssemblyCalculatorException>(innerException);
Assert.AreEqual(innerException.Message, exception.Message);
}
}
public void AssembleFailureMechanism_WithInput_SetsInputOnCalculator()
{
// Setup
var failureMechanism = new WaveImpactAsphaltCoverFailureMechanism
{
AssemblyResult =
{
ProbabilityResultType = FailureMechanismAssemblyProbabilityResultType.Automatic
}
};
failureMechanism.SetSections(new[]
{
FailureMechanismSectionTestFactory.CreateFailureMechanismSection()
}, "APath");
var assessmentSection = new AssessmentSectionStub();
using (new AssemblyToolCalculatorFactoryConfig())
{
var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance;
FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator;
FailureMechanismAssemblyCalculatorStub failureMechanismAssemblyCalculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator;
// Call
WaveImpactAsphaltCoverFailureMechanismAssemblyFactory.AssembleFailureMechanism(failureMechanism, assessmentSection);
// Assert
double expectedN = failureMechanism.GeneralWaveImpactAsphaltCoverInput.GetN(assessmentSection.ReferenceLine.Length);
Assert.AreEqual(expectedN, failureMechanismAssemblyCalculator.FailureMechanismN);
Assert.AreSame(calculator.FailureMechanismSectionAssemblyResultOutput.AssemblyResult, failureMechanismAssemblyCalculator.SectionAssemblyResultsInput.Single());
Assert.AreEqual(failureMechanism.GeneralWaveImpactAsphaltCoverInput.ApplyLengthEffectInSection, failureMechanismAssemblyCalculator.ApplyLengthEffect);
}
}
private FailureMechanismAssemblyResultRow CreateWaveImpactFailureMechanismAssemblyResultRow()
{
WaveImpactAsphaltCoverFailureMechanism waveImpactAsphaltCover = AssessmentSection.WaveImpactAsphaltCover;
return(FailureMechanismAssemblyResultRowFactory.CreateRow(
waveImpactAsphaltCover, () => WaveImpactAsphaltCoverFailureMechanismAssemblyFactory.AssembleFailureMechanism(waveImpactAsphaltCover, AssessmentSection)));
}
public void AssembleFailureMechanism_AssessmentSectionNull_ThrowsArgumentNullException()
{
// Setup
var failureMechanism = new WaveImpactAsphaltCoverFailureMechanism();
// Call
void Call() => WaveImpactAsphaltCoverFailureMechanismAssemblyFactory.AssembleFailureMechanism(failureMechanism, null);
// Assert
var exception = Assert.Throws <ArgumentNullException>(Call);
Assert.AreEqual("assessmentSection", exception.ParamName);
}
public override IEnumerable <ViewInfo> GetViewInfos()
{
yield return(new RiskeerViewInfo <HydraulicLoadsStateFailureMechanismContext, HydraulicLoadsStateFailureMechanismView>(() => Gui)
{
GetViewName = (view, context) => context.WrappedData.Name,
CreateInstance = context => new HydraulicLoadsStateFailureMechanismView(context.WrappedData, context.Parent)
});
yield return(new RiskeerViewInfo <RegistrationStateFailureMechanismContext, RegistrationStateFailureMechanismView>(() => Gui)
{
GetViewName = (view, context) => context.WrappedData.Name,
AdditionalDataCheck = context => context.WrappedData.InAssembly,
CreateInstance = context => new RegistrationStateFailureMechanismView(context.WrappedData, context.Parent),
CloseForData = CloseFailureMechanismViewForData
});
yield return(new RiskeerViewInfo <
WaveImpactAsphaltCoverFailureMechanismSectionResultContext,
IObservableEnumerable <NonAdoptableWithProfileProbabilityFailureMechanismSectionResult>,
NonAdoptableWithProfileProbabilityFailureMechanismResultView <WaveImpactAsphaltCoverFailureMechanism> >(() => Gui)
{
GetViewName = (view, context) => RiskeerCommonFormsResources.FailureMechanism_AssessmentResult_DisplayName,
CloseForData = CloseFailureMechanismResultViewForData,
GetViewData = context => context.WrappedData,
CreateInstance = context =>
{
var failureMechanism = (WaveImpactAsphaltCoverFailureMechanism)context.FailureMechanism;
IAssessmentSection assessmentSection = context.AssessmentSection;
return new NonAdoptableWithProfileProbabilityFailureMechanismResultView <WaveImpactAsphaltCoverFailureMechanism>(
context.WrappedData,
failureMechanism,
assessmentSection,
WaveImpactAsphaltCoverFailureMechanismAssemblyFactory.AssembleFailureMechanism,
fm => fm.GeneralWaveImpactAsphaltCoverInput.ApplyLengthEffectInSection,
sr => WaveImpactAsphaltCoverFailureMechanismAssemblyFactory.AssembleSection(sr, failureMechanism, assessmentSection));
}
});
yield return(new RiskeerViewInfo <WaveImpactAsphaltCoverWaveConditionsInputContext,
ICalculation <WaveConditionsInput>,
WaveConditionsInputView>(() => Gui)
{
GetViewName = (view, context) => RiskeerCommonFormsResources.Calculation_Input,
CloseForData = RiskeerPluginHelper.ShouldCloseViewWithCalculationData,
CreateInstance = context => new WaveConditionsInputView(
context.Calculation,
() => WaveConditionsInputHelper.GetHydraulicBoundaryLocationCalculation(context.WrappedData, context.AssessmentSection),
new WaveImpactAsphaltCoverWaveConditionsInputViewStyle())
});
}
public void AssembleSection_AssessmentSectionNull_ThrowsArgumentNullException()
{
// Setup
FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
var sectionResult = new NonAdoptableWithProfileProbabilityFailureMechanismSectionResult(section);
var failureMechanism = new WaveImpactAsphaltCoverFailureMechanism();
// Call
void Call() => WaveImpactAsphaltCoverFailureMechanismAssemblyFactory.AssembleSection(sectionResult, failureMechanism, null);
// Assert
var exception = Assert.Throws <ArgumentNullException>(Call);
Assert.AreEqual("assessmentSection", exception.ParamName);
}
public void AssembleFailureMechanism_FailureMechanismNull_ThrowsArgumentNullException()
{
// Setup
var mocks = new MockRepository();
var assessmentSection = mocks.Stub <IAssessmentSection>();
mocks.ReplayAll();
// Call
void Call() => WaveImpactAsphaltCoverFailureMechanismAssemblyFactory.AssembleFailureMechanism(null, assessmentSection);
// Assert
var exception = Assert.Throws <ArgumentNullException>(Call);
Assert.AreEqual("failureMechanism", exception.ParamName);
mocks.VerifyAll();
}
protected override void CreateMapData()
{
base.CreateMapData();
MapDataCollection sectionsMapDataCollection = RiskeerMapDataFactory.CreateSectionsMapDataCollection();
sectionsMapData = RiskeerMapDataFactory.CreateFailureMechanismSectionsMapData();
sectionsStartPointMapData = RiskeerMapDataFactory.CreateFailureMechanismSectionsStartPointMapData();
sectionsEndPointMapData = RiskeerMapDataFactory.CreateFailureMechanismSectionsEndPointMapData();
assemblyResultMapLayer = new NonCalculatableFailureMechanismSectionResultsMapLayer <NonAdoptableWithProfileProbabilityFailureMechanismSectionResult>(
FailureMechanism, sr => WaveImpactAsphaltCoverFailureMechanismAssemblyFactory.AssembleSection(sr, FailureMechanism, AssessmentSection).AssemblyResult);
sectionsMapDataCollection.Add(sectionsMapData);
sectionsMapDataCollection.Add(sectionsStartPointMapData);
sectionsMapDataCollection.Add(sectionsEndPointMapData);
MapDataCollection.Insert(1, sectionsMapDataCollection);
MapDataCollection.Insert(2, assemblyResultMapLayer.MapData);
}
public void AssembleSection_FailureMechanismNull_ThrowsArgumentNullException()
{
// Setup
var mocks = new MockRepository();
var assessmentSection = mocks.Stub <IAssessmentSection>();
mocks.ReplayAll();
FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
var sectionResult = new NonAdoptableWithProfileProbabilityFailureMechanismSectionResult(section);
// Call
void Call() => WaveImpactAsphaltCoverFailureMechanismAssemblyFactory.AssembleSection(sectionResult, null, assessmentSection);
// Assert
var exception = Assert.Throws <ArgumentNullException>(Call);
Assert.AreEqual("failureMechanism", exception.ParamName);
mocks.VerifyAll();
}
public void AssembleSection_WithInput_SetsInputOnCalculator()
{
// Setup
var random = new Random(21);
FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
var sectionResult = new NonAdoptableWithProfileProbabilityFailureMechanismSectionResult(section)
{
IsRelevant = random.NextBoolean(),
InitialFailureMechanismResultType = NonAdoptableInitialFailureMechanismResultType.Manual,
ManualInitialFailureMechanismResultSectionProbability = random.NextDouble(),
FurtherAnalysisType = random.NextEnumValue <FailureMechanismSectionResultFurtherAnalysisType>(),
RefinedSectionProbability = random.NextDouble()
};
var failureMechanism = new WaveImpactAsphaltCoverFailureMechanism();
var assessmentSection = new AssessmentSectionStub();
using (new AssemblyToolCalculatorFactoryConfig())
{
var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance;
FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator;
// Call
WaveImpactAsphaltCoverFailureMechanismAssemblyFactory.AssembleSection(sectionResult, failureMechanism, assessmentSection);
// Assert
FailureMechanismSectionAssemblyInput calculatorInput = calculator.FailureMechanismSectionAssemblyInput;
FailureMechanismContribution failureMechanismContribution = assessmentSection.FailureMechanismContribution;
Assert.AreEqual(failureMechanismContribution.SignalFloodingProbability, calculatorInput.SignalFloodingProbability);
Assert.AreEqual(failureMechanismContribution.MaximumAllowableFloodingProbability, calculatorInput.MaximumAllowableFloodingProbability);
Assert.AreEqual(sectionResult.IsRelevant, calculatorInput.IsRelevant);
Assert.IsTrue(calculatorInput.HasProbabilitySpecified);
Assert.AreEqual(sectionResult.ManualInitialFailureMechanismResultSectionProbability, calculatorInput.InitialSectionProbability);
Assert.AreEqual(sectionResult.FurtherAnalysisType, calculatorInput.FurtherAnalysisType);
Assert.AreEqual(sectionResult.RefinedSectionProbability, calculatorInput.RefinedSectionProbability);
}
}
public void AssembleSection_CalculatorRan_ReturnsExpectedOutput()
{
// Setup
FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
var sectionResult = new NonAdoptableWithProfileProbabilityFailureMechanismSectionResult(section);
var failureMechanism = new WaveImpactAsphaltCoverFailureMechanism();
var assessmentSection = new AssessmentSectionStub();
using (new AssemblyToolCalculatorFactoryConfig())
{
var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance;
FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator;
// Call
FailureMechanismSectionAssemblyResultWrapper result = WaveImpactAsphaltCoverFailureMechanismAssemblyFactory.AssembleSection(
sectionResult, failureMechanism, assessmentSection);
// Assert
Assert.AreSame(calculator.FailureMechanismSectionAssemblyResultOutput, result);
}
}
