public void ParameteredConstructor_ExpectedValues() { // Setup var mocks = new MockRepository(); var assessmentSection = mocks.Stub <IAssessmentSection>(); mocks.ReplayAll(); var calculation = new ProbabilisticPipingCalculationScenario(); var surfaceLines = new[] { new PipingSurfaceLine(string.Empty) }; PipingStochasticSoilModel[] stochasticSoilModels = { PipingStochasticSoilModelTestFactory.CreatePipingStochasticSoilModel() }; var failureMechanism = new PipingFailureMechanism(); // Call var context = new ProbabilisticPipingInputContext(calculation.InputParameters, calculation, surfaceLines, stochasticSoilModels, failureMechanism, assessmentSection); // Assert Assert.IsInstanceOf <PipingContext <ProbabilisticPipingInput> >(context); Assert.AreSame(calculation.InputParameters, context.WrappedData); Assert.AreSame(calculation, context.PipingCalculation); Assert.AreSame(failureMechanism, context.FailureMechanism); Assert.AreSame(assessmentSection, context.AssessmentSection); CollectionAssert.AreEqual(surfaceLines, context.AvailablePipingSurfaceLines); CollectionAssert.AreEqual(stochasticSoilModels, context.AvailableStochasticSoilModels); mocks.VerifyAll(); }
public void CloseForData_NestedViewCorrespondingToRemovedFailureMechanismContext_ReturnsTrue() { // Setup var assessmentSection = mocks.Stub <IAssessmentSection>(); mocks.ReplayAll(); var calculation = new ProbabilisticPipingCalculationScenario(); var calculationGroup = new CalculationGroup(); calculationGroup.Children.Add(calculation); var failureMechanism = new PipingFailureMechanism(); failureMechanism.CalculationsGroup.Children.Add(calculationGroup); var context = new PipingFailureMechanismContext(failureMechanism, assessmentSection); using (var view = new PipingInputView { Data = calculation }) { // Call bool closeForData = info.CloseForData(view, context); // Assert Assert.IsTrue(closeForData); mocks.VerifyAll(); } }
public void CloseForData_NestedViewNotCorrespondingToRemovedAssessmentSection_ReturnsFalse() { // Setup var calculation = new ProbabilisticPipingCalculationScenario(); var calculationGroup = new CalculationGroup(); calculationGroup.Children.Add(calculation); var failureMechanism = new PipingFailureMechanism(); failureMechanism.CalculationsGroup.Children.Add(calculationGroup); var assessmentSection = mocks.Stub <IAssessmentSection>(); assessmentSection.Stub(section => section.GetFailureMechanisms()).Return(new[] { failureMechanism }); mocks.ReplayAll(); using (var view = new PipingInputView { Data = new ProbabilisticPipingCalculationScenario() }) { // Call bool closeForData = info.CloseForData(view, assessmentSection); // Assert Assert.IsFalse(closeForData); mocks.VerifyAll(); } }
public void CloseForData_ViewNotCorrespondingToRemovedPipingCalculationScenarioContext_ReturnsFalse() { // Setup var assessmentSection = mocks.Stub <IAssessmentSection>(); mocks.ReplayAll(); var pipingCalculation = new ProbabilisticPipingCalculationScenario(); var calculationToRemove = new ProbabilisticPipingCalculationScenario(); var pipingCalculationScenarioContext = new ProbabilisticPipingCalculationScenarioContext(calculationToRemove, new CalculationGroup(), Enumerable.Empty <PipingSurfaceLine>(), Enumerable.Empty <PipingStochasticSoilModel>(), new PipingFailureMechanism(), assessmentSection); using (var view = new PipingInputView { Data = pipingCalculation }) { // Call bool closeForData = info.CloseForData(view, pipingCalculationScenarioContext); // Assert Assert.IsFalse(closeForData); mocks.VerifyAll(); } }
public void CloseForData_NestedViewNotCorrespondingWithRemovedParentPipingCalculationGroupContext_ReturnsFalse() { // Setup var assessmentSection = mocks.Stub <IAssessmentSection>(); mocks.ReplayAll(); var calculation = new ProbabilisticPipingCalculationScenario(); var nestedGroup = new CalculationGroup(); nestedGroup.Children.Add(calculation); var calculationGroup = new CalculationGroup(); calculationGroup.Children.Add(nestedGroup); var calculationGroupContext = new PipingCalculationGroupContext(new CalculationGroup(), null, Enumerable.Empty <PipingSurfaceLine>(), Enumerable.Empty <PipingStochasticSoilModel>(), new PipingFailureMechanism(), assessmentSection); using (var view = new PipingInputView { Data = calculation }) { // Call bool closeForData = info.CloseForData(view, calculationGroupContext); // Assert Assert.IsFalse(closeForData); mocks.VerifyAll(); } }
public void Read_EntityWithProbabilisticPipingCalculationOutputEntity_CalculationWithProbabilisticPipingOutput() { // Setup var entity = new ProbabilisticPipingCalculationEntity { ProbabilisticPipingCalculationOutputEntities = { new ProbabilisticPipingCalculationOutputEntity() } }; var collector = new ReadConversionCollector(); // Call ProbabilisticPipingCalculationScenario calculation = entity.Read(collector); // Assert ProbabilisticPipingOutput output = calculation.Output; Assert.IsNotNull(output); Assert.IsNaN(output.ProfileSpecificOutput.Reliability); Assert.IsNull(((PartialProbabilisticFaultTreePipingOutput)output.ProfileSpecificOutput).GeneralResult); Assert.IsNaN(output.SectionSpecificOutput.Reliability); Assert.IsNull(((PartialProbabilisticFaultTreePipingOutput)output.ProfileSpecificOutput).GeneralResult); }
public void Read_EntityWithStochasticSoilModelEntityInCollector_CalculationHasAlreadyReadStochasticSoilModel() { // Setup PipingStochasticSoilModel stochasticSoilModel = PipingStochasticSoilModelTestFactory.CreatePipingStochasticSoilModel(); var stochasticSoilModelEntity = new StochasticSoilModelEntity(); var stochasticSoilProfile = new PipingStochasticSoilProfile(1, PipingSoilProfileTestFactory.CreatePipingSoilProfile()); var stochasticSoilProfileEntity = new PipingStochasticSoilProfileEntity { StochasticSoilModelEntity = stochasticSoilModelEntity }; var entity = new ProbabilisticPipingCalculationEntity { PipingStochasticSoilProfileEntity = stochasticSoilProfileEntity, EntryPointL = 1, ExitPointL = 2, DampingFactorExitMean = 1 }; var collector = new ReadConversionCollector(); collector.Read(stochasticSoilProfileEntity, stochasticSoilProfile); collector.Read(stochasticSoilModelEntity, stochasticSoilModel); // Call ProbabilisticPipingCalculationScenario calculation = entity.Read(collector); // Assert Assert.AreSame(stochasticSoilProfile, calculation.InputParameters.StochasticSoilProfile); Assert.AreSame(stochasticSoilModel, calculation.InputParameters.StochasticSoilModel); }
public void Read_EntityWithSurfaceLineNotYetInCollector_CalculationWithCreatedSurfaceLineAndRegisteredNewEntities() { // Setup var points = new[] { new Point3D(1, 3, 4), new Point3D(7, 10, 11) }; var surfaceLineEntity = new SurfaceLineEntity { Name = "surface line", PointsXml = new Point3DCollectionXmlSerializer().ToXml(points) }; var entity = new ProbabilisticPipingCalculationEntity { SurfaceLineEntity = surfaceLineEntity, EntryPointL = 1, ExitPointL = 2, DampingFactorExitMean = 1 }; var collector = new ReadConversionCollector(); // Call ProbabilisticPipingCalculationScenario calculation = entity.Read(collector); // Assert Assert.IsTrue(collector.ContainsPipingSurfaceLine(surfaceLineEntity)); CollectionAssert.AreEqual(points, calculation.InputParameters.SurfaceLine.Points); }
public void ClearIllustrationPoints_CalculationWithOutputWithIllustrationPoints_ClearsIllustrationPointsAndReturnsTrue() { // Setup var mocks = new MockRepository(); var inquiryHelper = mocks.StrictMock <IInquiryHelper>(); mocks.ReplayAll(); var calculation = new ProbabilisticPipingCalculationScenario { Output = PipingTestDataGenerator.GetRandomProbabilisticPipingOutputWithIllustrationPoints() }; var handler = new ClearIllustrationPointsOfProbabilisticPipingCalculationChangeHandler(inquiryHelper, calculation); // Call bool result = handler.ClearIllustrationPoints(); // Assert Assert.IsTrue(result); Assert.IsNull(((PartialProbabilisticPipingOutput <TestTopLevelIllustrationPoint>)calculation.Output.ProfileSpecificOutput).GeneralResult); Assert.IsNull(((PartialProbabilisticPipingOutput <TestTopLevelIllustrationPoint>)calculation.Output.SectionSpecificOutput).GeneralResult); mocks.VerifyAll(); }
public void Create_StochasticSoilProfileSet_EntityHasStochasticSoilProfileEntity() { // Setup PipingSoilProfile soilProfile = PipingSoilProfileTestFactory.CreatePipingSoilProfile(); var stochasticSoilProfile = new PipingStochasticSoilProfile(0.6, soilProfile); PipingStochasticSoilModel soilModel = PipingStochasticSoilModelTestFactory.CreatePipingStochasticSoilModel("A", new[] { stochasticSoilProfile }); var registry = new PersistenceRegistry(); StochasticSoilModelEntity soilModelEntity = soilModel.Create(registry, 0); var calculation = new ProbabilisticPipingCalculationScenario { InputParameters = { StochasticSoilModel = soilModel, StochasticSoilProfile = stochasticSoilProfile } }; // Call ProbabilisticPipingCalculationEntity entity = calculation.Create(registry, 0); // Assert PipingStochasticSoilProfileEntity expectedStochasticSoilProfileEntity = soilModelEntity.PipingStochasticSoilProfileEntities.First(); Assert.AreSame(expectedStochasticSoilProfileEntity, entity.PipingStochasticSoilProfileEntity); Assert.IsTrue(registry.Contains(soilModel)); }
public void ParameteredConstructor_ParentNull_ThrowsArgumentNullException() { // Setup var mocks = new MockRepository(); var assessmentSection = mocks.Stub <IAssessmentSection>(); mocks.ReplayAll(); var surfaceLines = new[] { new PipingSurfaceLine(string.Empty) }; PipingStochasticSoilModel[] soilModels = { PipingStochasticSoilModelTestFactory.CreatePipingStochasticSoilModel() }; var calculation = new ProbabilisticPipingCalculationScenario(); var failureMechanism = new PipingFailureMechanism(); // Call TestDelegate call = () => new ProbabilisticPipingCalculationScenarioContext(calculation, null, surfaceLines, soilModels, failureMechanism, assessmentSection); // Assert var exception = Assert.Throws <ArgumentNullException>(call); Assert.AreEqual("parent", exception.ParamName); mocks.VerifyAll(); }
public void Create_HasCalculationOutput_EntityHasPipingCalculationOutputEntity() { // Setup var registry = new PersistenceRegistry(); var output = new ProbabilisticPipingOutput(PipingTestDataGenerator.GetRandomPartialProbabilisticFaultTreePipingOutput(), PipingTestDataGenerator.GetRandomPartialProbabilisticFaultTreePipingOutput()); var calculation = new ProbabilisticPipingCalculationScenario { Output = output }; // Call ProbabilisticPipingCalculationEntity entity = calculation.Create(registry, 0); // Assert ProbabilisticPipingCalculationOutputEntity outputEntity = entity.ProbabilisticPipingCalculationOutputEntities.SingleOrDefault(); Assert.IsNotNull(outputEntity); Assert.AreEqual(output.ProfileSpecificOutput.Reliability, outputEntity.ProfileSpecificReliability); Assert.AreEqual(output.SectionSpecificOutput.Reliability, outputEntity.SectionSpecificReliability); GeneralResultEntityTestHelper.AssertGeneralResultPropertyValues(((PartialProbabilisticFaultTreePipingOutput)output.ProfileSpecificOutput).GeneralResult, outputEntity.GeneralResultFaultTreeIllustrationPointEntity); GeneralResultEntityTestHelper.AssertGeneralResultPropertyValues(((PartialProbabilisticFaultTreePipingOutput)output.SectionSpecificOutput).GeneralResult, outputEntity.GeneralResultFaultTreeIllustrationPointEntity1); }
public void Read_EntityWithSurfaceLineInCollector_CalculationHasAlreadyReadSurfaceLine() { // Setup var surfaceLine = new PipingSurfaceLine(string.Empty); surfaceLine.SetGeometry(new[] { new Point3D(1, 2, 3), new Point3D(4, 5, 6) }); var surfaceLineEntity = new SurfaceLineEntity(); var entity = new ProbabilisticPipingCalculationEntity { SurfaceLineEntity = surfaceLineEntity, EntryPointL = 1, ExitPointL = 2, DampingFactorExitMean = 1 }; var collector = new ReadConversionCollector(); collector.Read(surfaceLineEntity, surfaceLine); // Call ProbabilisticPipingCalculationScenario calculation = entity.Read(collector); // Assert Assert.AreSame(surfaceLine, calculation.InputParameters.SurfaceLine); Assert.AreEqual(1, calculation.InputParameters.EntryPointL, 1e-6); Assert.AreEqual(2, calculation.InputParameters.ExitPointL, 1e-6); }
public void VerifyUpdates_CalculationWithOutputs_AlwaysReturnsExpectedInquiryMessage(bool isActionConfirmed) { // Setup string expectedInquiryMessage = "Als u een vakindeling importeert, dan worden de resultaten van alle probabilistische piping berekeningen verwijderd." + $"{Environment.NewLine}{Environment.NewLine}Weet u zeker dat u wilt doorgaan?"; var mocks = new MockRepository(); var inquiryHelper = mocks.StrictMock <IInquiryHelper>(); inquiryHelper.Expect(ih => ih.InquireContinuation(expectedInquiryMessage)) .Return(isActionConfirmed); var assessmentSection = mocks.Stub <IAssessmentSection>(); mocks.ReplayAll(); var failureMechanism = new PipingFailureMechanism(); var calculationWithOutput = new ProbabilisticPipingCalculationScenario { Output = PipingTestDataGenerator.GetRandomProbabilisticPipingOutputWithIllustrationPoints() }; failureMechanism.CalculationsGroup.Children.Add(calculationWithOutput); var context = new PipingFailureMechanismSectionsContext(failureMechanism, assessmentSection); ImportInfo <PipingFailureMechanismSectionsContext> importInfo = GetImportInfo(inquiryHelper); // Call bool updatesVerified = importInfo.VerifyUpdates(context); // Assert Assert.AreEqual(isActionConfirmed, updatesVerified); mocks.VerifyAll(); }
public void Create_HasSurfaceLineSet_EntityHasSurfaceLineEntity() { // Setup var surfaceLine = new PipingSurfaceLine(string.Empty) { ReferenceLineIntersectionWorldPoint = new Point2D(1.1, 2.2) }; surfaceLine.SetGeometry(new[] { new Point3D(0.0, 0.0, 1.0), new Point3D(3.3, 6.6, 1.0) }); var registry = new PersistenceRegistry(); SurfaceLineEntity surfaceLineEntity = surfaceLine.Create(registry, 0); var calculation = new ProbabilisticPipingCalculationScenario { InputParameters = { SurfaceLine = surfaceLine } }; // Call ProbabilisticPipingCalculationEntity entity = calculation.Create(registry, 0); // Assert Assert.AreSame(surfaceLineEntity, entity.SurfaceLineEntity); }
public DerivedProbabilisticPipingCalculationScenarioContext(ProbabilisticPipingCalculationScenario calculation, CalculationGroup parent, IEnumerable <PipingSurfaceLine> surfaceLines, IEnumerable <PipingStochasticSoilModel> stochasticSoilModels, PipingFailureMechanism pipingFailureMechanism, IAssessmentSection assessmentSection) : base(calculation, parent, surfaceLines, stochasticSoilModels, pipingFailureMechanism, assessmentSection) { }
/// <summary> /// Determines whether a <see cref="ProbabilisticPipingCalculationScenario"/> has illustration point results. /// </summary> /// <param name="calculation">The calculation to check.</param> /// <returns><c>true</c> when <paramref name="calculation"/> has illustration point results, <c>false</c> otherwise.</returns> /// <exception cref="ArgumentNullException">Thrown when <paramref name="calculation"/> is <c>null</c>.</exception> public static bool HasIllustrationPoints(ProbabilisticPipingCalculationScenario calculation) { if (calculation == null) { throw new ArgumentNullException(nameof(calculation)); } return(calculation.HasOutput && HasIllustrationPoints(calculation.Output)); }
public void VerifyUpdates_CalculationWithOutputs_AlwaysReturnsExpectedInquiryMessage(bool isActionConfirmed) { // Setup var mocks = new MockRepository(); var mainWindow = mocks.Stub <IMainWindow>(); var gui = mocks.Stub <IGui>(); gui.Stub(g => g.MainWindow).Return(mainWindow); var assessmentSection = mocks.Stub <IAssessmentSection>(); mocks.ReplayAll(); TestPipingFailureMechanism failureMechanism = TestPipingFailureMechanism.GetFailureMechanismWithSurfaceLinesAndStochasticSoilModels(); var calculationWithOutput = new ProbabilisticPipingCalculationScenario { Output = PipingTestDataGenerator.GetRandomProbabilisticPipingOutputWithIllustrationPoints() }; failureMechanism.CalculationsGroup.Children.Add(calculationWithOutput); var context = new PipingFailureMechanismSectionsContext(failureMechanism, assessmentSection); using (var plugin = new PipingPlugin()) { plugin.Gui = gui; string textBoxMessage = null; DialogBoxHandler = (name, wnd) => { var helper = new MessageBoxTester(wnd); textBoxMessage = helper.Text; if (isActionConfirmed) { helper.ClickOk(); } else { helper.ClickCancel(); } }; UpdateInfo updateInfo = GetUpdateInfo(plugin); // Call bool updatesVerified = updateInfo.VerifyUpdates(context); // Assert string expectedInquiryMessage = "Als u de vakindeling wijzigt, dan worden de resultaten van alle probabilistische piping berekeningen verwijderd." + $"{Environment.NewLine}{Environment.NewLine}Weet u zeker dat u wilt doorgaan?"; Assert.AreEqual(expectedInquiryMessage, textBoxMessage); Assert.AreEqual(isActionConfirmed, updatesVerified); } mocks.VerifyAll(); }
public void HasIllustrationPoints_WithVariousCalculationConfigurations_ReturnsExpectedResult( ProbabilisticPipingCalculationScenario calculation, bool expectedHasIllustrationPoints) { // Call bool hasIllustrationPoints = ProbabilisticPipingIllustrationPointsHelper.HasIllustrationPoints(calculation); // Assert Assert.AreEqual(expectedHasIllustrationPoints, hasIllustrationPoints); }
private static void ReadCalculationOutputs(ProbabilisticPipingCalculationScenario calculation, ProbabilisticPipingCalculationEntity entity) { ProbabilisticPipingCalculationOutputEntity calculationOutputEntity = entity.ProbabilisticPipingCalculationOutputEntities.SingleOrDefault(); if (calculationOutputEntity != null) { calculation.Output = calculationOutputEntity.Read(); } }
public void Clone_NotAllPropertiesSet_ReturnNewInstanceWithCopiedValues() { // Setup ProbabilisticPipingCalculationScenario original = CreateRandomCalculationScenarioWithoutOutput(); // Call object clone = original.Clone(); // Assert CoreCloneAssert.AreObjectClones(original, clone, PipingCloneAssert.AreClones); }
public void Contribution_SetValidValue_ValueSet(double newValue) { // Setup var calculationScenario = new ProbabilisticPipingCalculationScenario(); // Call calculationScenario.Contribution = (RoundedDouble)newValue; // Assert Assert.AreEqual(4, calculationScenario.Contribution.NumberOfDecimalPlaces); Assert.AreEqual(newValue, calculationScenario.Contribution, calculationScenario.Contribution.GetAccuracy()); }
public void Constructor_CalculationWithoutOutput_ExpectedValues() { // Setup var calculation = new ProbabilisticPipingCalculationScenario(); // Call var row = new ProbabilisticPipingScenarioRow(calculation); // Assert Assert.IsNaN(row.FailureProbability); Assert.IsNaN(row.SectionFailureProbability); }
public void GetViewData_WithContext_ReturnsWrappedCalculationScenario() { // Setup var calculationScenario = new ProbabilisticPipingCalculationScenario(); var context = new ProbabilisticPipingSectionSpecificOutputContext(calculationScenario); // Call object viewData = info.GetViewData(context); // Assert Assert.AreSame(calculationScenario, viewData); }
public void Constructor_ExpectedValues() { // Setup var calculation = new ProbabilisticPipingCalculationScenario(); // Call var row = new ProbabilisticPipingScenarioRow(calculation); // Assert Assert.IsInstanceOf <PipingScenarioRow <ProbabilisticPipingCalculationScenario> >(row); Assert.AreSame(calculation, row.CalculationScenario); }
public void Constructor_ExpectedValues() { // Setup var calculation = new ProbabilisticPipingCalculationScenario(); // Call var context = new ProbabilisticPipingOutputContext(calculation); // Assert Assert.IsInstanceOf <ObservableWrappedObjectContextBase <ProbabilisticPipingCalculationScenario> >(context); Assert.AreSame(calculation, context.WrappedData); }
public void ClearIllustrationPoints_Always_ReturnsAffectedCalculations() { // Setup var calculationWitNoIllustrationPoints = new ProbabilisticPipingCalculationScenario { Output = PipingTestDataGenerator.GetRandomProbabilisticPipingOutputWithoutIllustrationPoints() }; var calculationWithIllustrationPoints = new ProbabilisticPipingCalculationScenario { Output = PipingTestDataGenerator.GetRandomProbabilisticPipingOutputWithIllustrationPoints() }; ProbabilisticPipingCalculationScenario[] calculations = { calculationWitNoIllustrationPoints, calculationWithIllustrationPoints, new ProbabilisticPipingCalculationScenario() }; var mocks = new MockRepository(); var inquiryHelper = mocks.StrictMock <IInquiryHelper>(); mocks.ReplayAll(); var handler = new ClearIllustrationPointsOfProbabilisticPipingCalculationCollectionChangeHandler( inquiryHelper, calculations); // Call IEnumerable <IObservable> affectedObjects = handler.ClearIllustrationPoints(); // Assert CollectionAssert.AreEquivalent(new[] { calculationWithIllustrationPoints }, affectedObjects); ProbabilisticPipingCalculationScenario[] calculationsWithOutput = { calculationWitNoIllustrationPoints, calculationWithIllustrationPoints }; Assert.IsTrue(calculationsWithOutput.All(calc => calc.HasOutput)); Assert.IsTrue(calculationsWithOutput.All(calc => { ProbabilisticPipingOutput output = calc.Output; return(!output.ProfileSpecificOutput.HasGeneralResult && !output.SectionSpecificOutput.HasGeneralResult); })); mocks.VerifyAll(); }
public void Contribution_SetInvalidValue_ThrowArgumentException(double newValue) { // Setup var calculationScenario = new ProbabilisticPipingCalculationScenario(); // Call void Call() => calculationScenario.Contribution = (RoundedDouble)newValue; // Assert const string expectedMessage = "De waarde voor de bijdrage moet binnen het bereik [0, 100] liggen."; TestHelper.AssertThrowsArgumentExceptionAndTestMessage <ArgumentOutOfRangeException>(Call, expectedMessage); }
public void Create_PersistenceRegistryIsNull_ThrowArgumentNullException() { // Setup var calculation = new ProbabilisticPipingCalculationScenario(); // Call void Call() => calculation.Create(null, 0); // Assert var exception = Assert.Throws <ArgumentNullException>(Call); Assert.AreEqual("registry", exception.ParamName); }
public void Clone_AllPropertiesSet_ReturnNewInstanceWithCopiedValues() { // Setup ProbabilisticPipingCalculationScenario original = CreateRandomCalculationScenarioWithoutOutput(); original.Output = PipingTestDataGenerator.GetRandomProbabilisticPipingOutputWithIllustrationPoints(); // Call object clone = original.Clone(); // Assert CoreCloneAssert.AreObjectClones(original, clone, PipingCloneAssert.AreClones); }