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);
}
