public void ClearAllProbabilisticCalculationOutput_WithVariousCalculations_ClearsProbabilisticCalculationsOutputAndReturnsAffectedCalculations()
{
// Setup
PipingFailureMechanism failureMechanism = PipingTestDataGenerator.GetPipingFailureMechanismWithAllCalculationConfigurations();
failureMechanism.CalculationsGroup.Children.AddRange(new[]
{
new ProbabilisticPipingCalculationScenario
{
Output = PipingTestDataGenerator.GetRandomProbabilisticPipingOutputWithIllustrationPoints()
},
new ProbabilisticPipingCalculationScenario
{
Output = PipingTestDataGenerator.GetRandomProbabilisticPipingOutputWithoutIllustrationPoints()
},
new ProbabilisticPipingCalculationScenario()
});
ProbabilisticPipingCalculationScenario[] expectedAffectedCalculations = failureMechanism.Calculations
.OfType <ProbabilisticPipingCalculationScenario>()
.Where(c => c.HasOutput)
.ToArray();
// Call
IEnumerable <IObservable> affectedItems = PipingDataSynchronizationService.ClearAllProbabilisticCalculationOutput(failureMechanism);
// Assert
// Note: To make sure the clear is performed regardless of what is done with
// the return result, no ToArray() should be called before these assertions:
Assert.IsTrue(failureMechanism.Calculations
.OfType <ProbabilisticPipingCalculationScenario>()
.All(c => !c.HasOutput));
CollectionAssert.AreEquivalent(expectedAffectedCalculations, affectedItems);
}
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 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 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 Clone_AllPropertiesSet_ReturnNewInstanceWithCopiedValues()
{
// Setup
ProbabilisticPipingOutput original = PipingTestDataGenerator.GetRandomProbabilisticPipingOutputWithIllustrationPoints();
// Call
object clone = original.Clone();
// Assert
CoreCloneAssert.AreObjectClones(original, clone, PipingCloneAssert.AreClones);
}
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 HasOutput_OutputSet_ReturnsTrue()
{
// Setup
var calculation = new TestProbabilisticPipingCalculation
{
Output = PipingTestDataGenerator.GetRandomProbabilisticPipingOutputWithIllustrationPoints()
};
// Call
bool hasOutput = calculation.HasOutput;
// Assert
Assert.IsTrue(hasOutput);
}
public void ClearOutput_Always_SetsOutputToNull()
{
// Setup
var calculation = new TestProbabilisticPipingCalculation
{
Output = PipingTestDataGenerator.GetRandomProbabilisticPipingOutputWithIllustrationPoints()
};
// Call
calculation.ClearOutput();
// Assert
Assert.IsNull(calculation.Output);
}
public void AdditionalDataCheck_CalculationWithoutSubMechanismOutput_ReturnsFalse()
{
// Setup
var calculation = new ProbabilisticPipingCalculationScenario
{
Output = PipingTestDataGenerator.GetRandomProbabilisticPipingOutputWithIllustrationPoints()
};
var context = new ProbabilisticPipingSectionSpecificOutputContext(calculation);
// Call
bool additionalDataCheck = info.AdditionalDataCheck(context);
// Assert
Assert.IsFalse(additionalDataCheck);
}
public void ForeColor_HasOutput_ReturnControlText()
{
// Setup
var calculation = new ProbabilisticPipingCalculationScenario
{
Output = PipingTestDataGenerator.GetRandomProbabilisticPipingOutputWithIllustrationPoints()
};
var context = new ProbabilisticPipingOutputContext(calculation);
// Call
Color color = info.ForeColor(context);
// Assert
Assert.AreEqual(Color.FromKnownColor(KnownColor.ControlText), color);
}
private static IEnumerable <TestCaseData> GetCalculationConfigurations()
{
var calculationWithIllustrationPoints = new ProbabilisticPipingCalculationScenario
{
Output = PipingTestDataGenerator.GetRandomProbabilisticPipingOutputWithIllustrationPoints()
};
var calculationWithNoIllustrationPoints = new ProbabilisticPipingCalculationScenario
{
Output = PipingTestDataGenerator.GetRandomProbabilisticPipingOutputWithoutIllustrationPoints()
};
yield return(new TestCaseData(calculationWithIllustrationPoints, true));
yield return(new TestCaseData(calculationWithNoIllustrationPoints, false));
yield return(new TestCaseData(new ProbabilisticPipingCalculationScenario(), false));
}
public void DoPostUpdateActions_Always_ClearsAllProbabilisticOutputAndReturnsAffectedObjects()
{
// Setup
var calculation1 = new ProbabilisticPipingCalculationScenario
{
Output = PipingTestDataGenerator.GetRandomProbabilisticPipingOutputWithIllustrationPoints()
};
var calculation2 = new ProbabilisticPipingCalculationScenario
{
Output = PipingTestDataGenerator.GetRandomProbabilisticPipingOutputWithoutIllustrationPoints()
};
var calculation3 = new SemiProbabilisticPipingCalculationScenario
{
Output = PipingTestDataGenerator.GetSemiProbabilisticPipingOutput(double.NaN, double.NaN, double.NaN)
};
var failureMechanism = new PipingFailureMechanism();
failureMechanism.CalculationsGroup.Children.AddRange(new ICalculation[]
{
calculation1,
calculation2,
calculation3,
new ProbabilisticPipingCalculationScenario()
});
var replaceStrategy = new PipingFailureMechanismSectionReplaceStrategy(failureMechanism);
// Call
IEnumerable <IObservable> affectedObjects = replaceStrategy.DoPostUpdateActions();
// Assert
Assert.IsFalse(calculation1.HasOutput);
Assert.IsFalse(calculation2.HasOutput);
Assert.IsTrue(calculation3.HasOutput);
CollectionAssert.AreEqual(new[]
{
calculation1,
calculation2
}, affectedObjects);
}
public void ChildNodeObjects_Always_ReturnsCollectionWithOutputObjects(bool hasOutput)
{
// Setup
var calculation = new ProbabilisticPipingCalculationScenario
{
Output = hasOutput ? PipingTestDataGenerator.GetRandomProbabilisticPipingOutputWithIllustrationPoints() : null
};
var context = new ProbabilisticPipingOutputContext(calculation);
// Call
object[] children = info.ChildNodeObjects(context).ToArray();
// Assert
Assert.AreEqual(2, children.Length);
var profileSpecificOutputContext = children[0] as ProbabilisticPipingProfileSpecificOutputContext;
Assert.AreSame(calculation, profileSpecificOutputContext.WrappedData);
var sectionSpecificOutputContext = children[1] as ProbabilisticPipingSectionSpecificOutputContext;
Assert.AreSame(calculation, sectionSpecificOutputContext.WrappedData);
}
public void ContextMenuStrip_FailureMechanismHasCalculationsWithIllustrationPoints_ContextMenuItemClearAllIllustrationPointsOutputEnabledAndToolTipSet()
{
// Setup
using (var treeViewControl = new TreeViewControl())
{
var pipingCalculation = new ProbabilisticPipingCalculationScenario
{
Output = PipingTestDataGenerator.GetRandomProbabilisticPipingOutputWithIllustrationPoints()
};
var failureMechanism = new PipingFailureMechanism();
failureMechanism.CalculationsGroup.Children.Add(pipingCalculation);
var assessmentSection = mocks.Stub <IAssessmentSection>();
var context = new PipingFailureMechanismContext(failureMechanism, assessmentSection);
var menuBuilder = new CustomItemsOnlyContextMenuBuilder();
var gui = mocks.Stub <IGui>();
gui.Stub(cmp => cmp.Get(context, treeViewControl)).Return(menuBuilder);
gui.Stub(cmp => cmp.MainWindow).Return(mocks.Stub <IMainWindow>());
mocks.ReplayAll();
plugin.Gui = gui;
failureMechanism.CalculationsGroup.Children.Add(pipingCalculation);
// Call
using (ContextMenuStrip contextMenu = info.ContextMenuStrip(context, null, treeViewControl))
{
// Assert
ToolStripItem clearOutputItem = contextMenu.Items[contextMenuClearIllustrationPointsIndex];
Assert.IsTrue(clearOutputItem.Enabled);
Assert.AreEqual("Wis alle berekende illustratiepunten binnen dit faalmechanisme.", clearOutputItem.ToolTipText);
}
}
}
public void RequireConfirmation_ProbabilisticCalculationsWithOutput_ReturnsTrue()
{
// Setup
var mocks = new MockRepository();
var inquiryHelper = mocks.Stub <IInquiryHelper>();
mocks.ReplayAll();
var failureMechanism = new PipingFailureMechanism();
failureMechanism.CalculationsGroup.Children.Add(new ProbabilisticPipingCalculationScenario
{
Output = PipingTestDataGenerator.GetRandomProbabilisticPipingOutputWithIllustrationPoints()
});
var changeHandler = new PipingFailureMechanismCalculationChangeHandler(failureMechanism, string.Empty, inquiryHelper);
// Call
bool requireConfirmation = changeHandler.RequireConfirmation();
// Assert
Assert.IsTrue(requireConfirmation);
mocks.VerifyAll();
}
private static IEnumerable <TestCaseData> GetCalculations()
{
yield return(new TestCaseData(new TestProbabilisticPipingCalculation(), true)
.SetName("WithoutOutput"));
yield return(new TestCaseData(new TestProbabilisticPipingCalculation
{
Output = PipingTestDataGenerator.GetRandomProbabilisticPipingOutputWithIllustrationPoints()
}, true).SetName("WithOutputButShouldNotHaveIllustrationPoints"));
yield return(new TestCaseData(new TestProbabilisticPipingCalculation
{
InputParameters =
{
ShouldSectionSpecificIllustrationPointsBeCalculated = true,
ShouldProfileSpecificIllustrationPointsBeCalculated = true
},
Output = PipingTestDataGenerator.GetRandomProbabilisticPipingOutputWithIllustrationPoints()
}, false).SetName("WithOutputAndIllustrationPoints"));
yield return(new TestCaseData(new TestProbabilisticPipingCalculation
{
InputParameters =
{
ShouldSectionSpecificIllustrationPointsBeCalculated = false,
ShouldProfileSpecificIllustrationPointsBeCalculated = true
},
Output = PipingTestDataGenerator.GetRandomProbabilisticPipingOutputWithIllustrationPoints()
}, true).SetName("WithOutputAndPartialIllustrationPoints1"));
yield return(new TestCaseData(new TestProbabilisticPipingCalculation
{
InputParameters =
{
ShouldSectionSpecificIllustrationPointsBeCalculated = true,
ShouldProfileSpecificIllustrationPointsBeCalculated = false
},
Output = PipingTestDataGenerator.GetRandomProbabilisticPipingOutputWithIllustrationPoints()
}, true).SetName("WithOutputAndPartialIllustrationPoints2"));
yield return(new TestCaseData(new TestProbabilisticPipingCalculation
{
InputParameters =
{
ShouldSectionSpecificIllustrationPointsBeCalculated = true,
ShouldProfileSpecificIllustrationPointsBeCalculated = false
},
Output = new ProbabilisticPipingOutput(
PipingTestDataGenerator.GetRandomPartialProbabilisticPipingOutput(),
PipingTestDataGenerator.GetRandomPartialProbabilisticPipingOutput(null))
}, false).SetName("WithOutputAndPartialIllustrationPoints3"));
yield return(new TestCaseData(new TestProbabilisticPipingCalculation
{
InputParameters =
{
ShouldSectionSpecificIllustrationPointsBeCalculated = false,
ShouldProfileSpecificIllustrationPointsBeCalculated = true
},
Output = new ProbabilisticPipingOutput(
PipingTestDataGenerator.GetRandomPartialProbabilisticPipingOutput(null),
PipingTestDataGenerator.GetRandomPartialProbabilisticPipingOutput())
}, false).SetName("WithOutputAndPartialIllustrationPoints4"));
yield return(new TestCaseData(new TestProbabilisticPipingCalculation
{
InputParameters =
{
ShouldSectionSpecificIllustrationPointsBeCalculated = false,
ShouldProfileSpecificIllustrationPointsBeCalculated = false
},
Output = new ProbabilisticPipingOutput(
PipingTestDataGenerator.GetRandomPartialProbabilisticPipingOutput(null),
PipingTestDataGenerator.GetRandomPartialProbabilisticPipingOutput(null))
}, false).SetName("WithOutputWithoutIllustrationPoints"));
}
