public void UpdateModelWithImportedData_WithCurrentModelsAndImportedMultipleModelsWithSameName_ThrowsUpdateDataException()
{
// Setup
const string nonUniqueName = "non-unique name";
var targetCollection = new PipingStochasticSoilModelCollection();
targetCollection.AddRange(new[]
{
PipingStochasticSoilModelTestFactory.CreatePipingStochasticSoilModel(nonUniqueName)
}, sourceFilePath);
var strategy = new PipingStochasticSoilModelUpdateDataStrategy(new PipingFailureMechanism());
PipingStochasticSoilModel[] importedStochasticSoilModels =
{
PipingStochasticSoilModelTestFactory.CreatePipingStochasticSoilModel(nonUniqueName),
PipingStochasticSoilModelTestFactory.CreatePipingStochasticSoilModel(nonUniqueName)
};
// Call
TestDelegate test = () => strategy.UpdateModelWithImportedData(importedStochasticSoilModels, sourceFilePath);
// Assert
var exception = Assert.Throws <UpdateDataException>(test);
const string expectedMessage = "Geïmporteerde data moet unieke elementen bevatten.";
Assert.AreEqual(expectedMessage, exception.Message);
}
public void Create_WithStochasticSoilModels_ReturnsFailureMechanismEntityWithStochasticSoilModelEntities()
{
// Setup
var failureMechanism = new PipingFailureMechanism();
PipingStochasticSoilModelCollection stochasticSoilModels = failureMechanism.StochasticSoilModels;
stochasticSoilModels.AddRange(new[]
{
PipingStochasticSoilModelTestFactory.CreatePipingStochasticSoilModel("name"),
PipingStochasticSoilModelTestFactory.CreatePipingStochasticSoilModel("name2")
}, "some/path/to/file");
var registry = new PersistenceRegistry();
// Call
FailureMechanismEntity entity = failureMechanism.Create(registry);
// Assert
Assert.IsNotNull(entity);
Assert.AreEqual(stochasticSoilModels.Count, entity.StochasticSoilModelEntities.Count);
for (var i = 0; i < stochasticSoilModels.Count; i++)
{
AssertStochasticSoilModel(stochasticSoilModels[i],
entity.StochasticSoilModelEntities.ElementAt(i));
}
string stochasticSoilModelCollectionSourcePath = entity.PipingFailureMechanismMetaEntities
.Single()
.StochasticSoilModelCollectionSourcePath;
TestHelper.AssertAreEqualButNotSame(stochasticSoilModels.SourcePath, stochasticSoilModelCollectionSourcePath);
}
public void UpdateModelWithImportedData_UpdateCurrentModelWithImportedModelWithOtherProfiles_ProfilesAdded()
{
// Setup
const string modelsName = "same model";
PipingStochasticSoilModel existingModel = PipingStochasticSoilModelTestFactory.CreatePipingStochasticSoilModel(modelsName);
var failureMechanism = new PipingFailureMechanism();
PipingStochasticSoilModelCollection targetCollection = failureMechanism.StochasticSoilModels;
targetCollection.AddRange(new[]
{
existingModel
}, sourceFilePath);
var strategy = new PipingStochasticSoilModelUpdateDataStrategy(failureMechanism);
PipingStochasticSoilModel readModel = CreateSimpleModel(modelsName, "new profile A", "new profile B");
// Call
IEnumerable <IObservable> affectedObjects = strategy.UpdateModelWithImportedData(new[]
{
readModel
}, sourceFilePath);
// Assert
Assert.AreEqual(1, targetCollection.Count);
Assert.AreSame(existingModel, targetCollection[0]);
Assert.AreEqual(2, targetCollection[0].StochasticSoilProfiles.Count());
CollectionAssert.AreEquivalent(new IObservable[]
{
targetCollection,
existingModel
}, affectedObjects);
}
public void CurrentPath_StochasticSoilModelCollectionHasPathSet_ReturnsExpectedPath()
{
// Setup
var mocks = new MockRepository();
var assessmentSection = mocks.Stub <IAssessmentSection>();
mocks.ReplayAll();
const string expectedFilePath = "some/path";
var stochasticSoilModelCollection = new PipingStochasticSoilModelCollection();
stochasticSoilModelCollection.AddRange(new[]
{
PipingStochasticSoilModelTestFactory.CreatePipingStochasticSoilModel()
}, expectedFilePath);
var failureMechanism = new PipingFailureMechanism();
var context = new PipingStochasticSoilModelCollectionContext(stochasticSoilModelCollection, failureMechanism, assessmentSection);
// Call
string currentPath = updateInfo.CurrentPath(context);
// Assert
Assert.AreEqual(expectedFilePath, currentPath);
mocks.VerifyAll();
}
public void VerifyUpdates_CalculationWithoutOutputs_ReturnsTrue()
{
// Setup
var mocks = new MockRepository();
var assessmentSection = mocks.Stub <IAssessmentSection>();
var mainWindow = mocks.Stub <IMainWindow>();
var gui = mocks.Stub <IGui>();
gui.Stub(g => g.MainWindow).Return(mainWindow);
mocks.ReplayAll();
plugin.Gui = gui;
var failureMechanism = new PipingFailureMechanism();
failureMechanism.CalculationsGroup.Children.Add(new SemiProbabilisticPipingCalculationScenario());
var stochasticSoilModelCollection = new PipingStochasticSoilModelCollection();
var context = new PipingStochasticSoilModelCollectionContext(stochasticSoilModelCollection, failureMechanism, assessmentSection);
// Call
bool updatesVerified = importInfo.VerifyUpdates(context);
// Assert
Assert.IsTrue(updatesVerified);
mocks.VerifyAll();
}
public void UpdateModelWithImportedData_ProfilesAssignedToCalculationsWithOneImportedModelProfileRemoved_OneProfileRemovedCalculationUpdatedAccordingly()
{
// Setup
const string modelsName = "same model";
PipingStochasticSoilModel existingModel = CreateSimpleModel(modelsName, "Unaffected Profile", "Removed Profile");
var failureMechanism = new PipingFailureMechanism();
PipingStochasticSoilModelCollection targetCollection = failureMechanism.StochasticSoilModels;
targetCollection.AddRange(new[]
{
existingModel
}, sourceFilePath);
PipingStochasticSoilProfile firstExistingProfile = existingModel.StochasticSoilProfiles.First();
PipingStochasticSoilModel readModel = CreateSimpleModel(modelsName, firstExistingProfile.SoilProfile.Name);
var calculationWithNotUpdatedProfile = new SemiProbabilisticPipingCalculationScenario();
calculationWithNotUpdatedProfile.InputParameters.StochasticSoilModel = existingModel;
calculationWithNotUpdatedProfile.InputParameters.StochasticSoilProfile = existingModel.StochasticSoilProfiles.ElementAt(0);
calculationWithNotUpdatedProfile.Output = new SemiProbabilisticPipingOutput(new SemiProbabilisticPipingOutput.ConstructionProperties());
var calculationWithDeletedProfile = new SemiProbabilisticPipingCalculationScenario();
calculationWithDeletedProfile.InputParameters.StochasticSoilModel = existingModel;
calculationWithDeletedProfile.InputParameters.StochasticSoilProfile = existingModel.StochasticSoilProfiles.ElementAt(1);
calculationWithDeletedProfile.Output = new SemiProbabilisticPipingOutput(new SemiProbabilisticPipingOutput.ConstructionProperties());
failureMechanism.CalculationsGroup.Children.Add(calculationWithDeletedProfile);
failureMechanism.CalculationsGroup.Children.Add(calculationWithNotUpdatedProfile);
var strategy = new PipingStochasticSoilModelUpdateDataStrategy(failureMechanism);
// Call
IEnumerable <IObservable> affectedObjects = strategy.UpdateModelWithImportedData(new[]
{
readModel
}, sourceFilePath).ToArray();
// Assert
PipingStochasticSoilModel firstSoilModel = targetCollection[0];
Assert.AreSame(existingModel, firstSoilModel);
Assert.AreSame(firstExistingProfile, firstSoilModel.StochasticSoilProfiles.ElementAt(0));
Assert.IsTrue(calculationWithNotUpdatedProfile.HasOutput);
CollectionAssert.DoesNotContain(affectedObjects, calculationWithNotUpdatedProfile);
CollectionAssert.DoesNotContain(affectedObjects, calculationWithNotUpdatedProfile.InputParameters);
Assert.IsFalse(calculationWithDeletedProfile.HasOutput);
Assert.IsNull(calculationWithDeletedProfile.InputParameters.StochasticSoilProfile);
CollectionAssert.Contains(affectedObjects, calculationWithDeletedProfile);
CollectionAssert.Contains(affectedObjects, calculationWithDeletedProfile.InputParameters);
}
public void VerifyUpdates_CalculationWithOutputs_AlwaysReturnsExpectedInquiryMessage(bool isActionConfirmed)
{
// Setup
var mocks = new MockRepository();
var assessmentSection = mocks.Stub <IAssessmentSection>();
var mainWindow = mocks.Stub <IMainWindow>();
var gui = mocks.Stub <IGui>();
gui.Stub(g => g.MainWindow).Return(mainWindow);
mocks.ReplayAll();
plugin.Gui = gui;
var failureMechanism = new PipingFailureMechanism();
var calculationWithOutput = new SemiProbabilisticPipingCalculationScenario
{
Output = PipingTestDataGenerator.GetRandomSemiProbabilisticPipingOutput()
};
failureMechanism.CalculationsGroup.Children.Add(calculationWithOutput);
var stochasticSoilModelCollection = new PipingStochasticSoilModelCollection();
var context = new PipingStochasticSoilModelCollectionContext(stochasticSoilModelCollection, failureMechanism, assessmentSection);
string textBoxMessage = null;
DialogBoxHandler = (name, wnd) =>
{
var helper = new MessageBoxTester(wnd);
textBoxMessage = helper.Text;
if (isActionConfirmed)
{
helper.ClickOk();
}
else
{
helper.ClickCancel();
}
};
// Call
bool updatesVerified = importInfo.VerifyUpdates(context);
// Assert
string expectedInquiryMessage = "Als u stochastische ondergrondmodellen importeert, " +
"dan worden alle rekenresultaten van dit faalmechanisme verwijderd." +
$"{Environment.NewLine}{Environment.NewLine}Weet u zeker dat u wilt doorgaan?";
Assert.AreEqual(expectedInquiryMessage, textBoxMessage);
Assert.AreEqual(isActionConfirmed, updatesVerified);
mocks.VerifyAll();
}
public void UpdateModelWithImportedData_WithoutCurrentModelAndNoImportedModels_NoChangeNoNotification()
{
// Setup
var strategy = new PipingStochasticSoilModelUpdateDataStrategy(new PipingFailureMechanism());
var targetCollection = new PipingStochasticSoilModelCollection();
// Call
IEnumerable <IObservable> affectedObjects = strategy.UpdateModelWithImportedData(Enumerable.Empty <PipingStochasticSoilModel>(), "path");
// Assert
CollectionAssert.IsEmpty(targetCollection);
CollectionAssert.IsEmpty(affectedObjects);
}
/// <summary>
/// Creates a new instance of <see cref="PipingFailureMechanism"/>.
/// </summary>
public PipingFailureMechanism()
: base(PipingDataResources.PipingFailureMechanism_DisplayName, PipingDataResources.PipingFailureMechanism_DisplayCode)
{
PipingProbabilityAssessmentInput = new PipingProbabilityAssessmentInput();
GeneralInput = new GeneralPipingInput();
SurfaceLines = new PipingSurfaceLineCollection();
StochasticSoilModels = new PipingStochasticSoilModelCollection();
CalculationsGroup = new CalculationGroup
{
Name = RiskeerCommonDataResources.FailureMechanism_Calculations_DisplayName
};
ScenarioConfigurationType = PipingScenarioConfigurationType.SemiProbabilistic;
scenarioConfigurationsPerFailureMechanismSection = new ObservableList <PipingScenarioConfigurationPerFailureMechanismSection>();
CalculationsInputComments = new Comment();
}
public void Constructor_WithData_ReturnExpectedValues()
{
// Setup
const string someFilePath = "location/to/a/file";
var collection = new PipingStochasticSoilModelCollection();
collection.AddRange(Enumerable.Empty <PipingStochasticSoilModel>(), someFilePath);
// Call
var properties = new PipingStochasticSoilModelCollectionProperties(collection);
// Assert
Assert.IsInstanceOf <ObjectProperties <PipingStochasticSoilModelCollection> >(properties);
Assert.AreSame(collection, properties.Data);
Assert.AreEqual(someFilePath, properties.SourcePath);
}
public void ParameteredConstructor_FailureMechanismNull_ThrowsArgumentNullException()
{
// Setup
var mocks = new MockRepository();
var assessmentSection = mocks.Stub <IAssessmentSection>();
mocks.ReplayAll();
var stochasticSoilModels = new PipingStochasticSoilModelCollection();
// Call
TestDelegate test = () => new PipingStochasticSoilModelCollectionContext(stochasticSoilModels, null, assessmentSection);
// Assert
var exception = Assert.Throws <ArgumentNullException>(test);
Assert.AreEqual("failureMechanism", exception.ParamName);
mocks.VerifyAll();
}
public void IsEnabled_SoilModelCollectionSourcePathNull_ReturnFalse()
{
// Setup
var mocks = new MockRepository();
var assessmentSection = mocks.Stub <IAssessmentSection>();
mocks.ReplayAll();
var failureMechanism = new PipingFailureMechanism();
var stochasticSoilModel = new PipingStochasticSoilModelCollection();
var context = new PipingStochasticSoilModelCollectionContext(stochasticSoilModel, failureMechanism, assessmentSection);
// Call
bool isEnabled = updateInfo.IsEnabled(context);
// Assert
Assert.IsFalse(isEnabled);
mocks.VerifyAll();
}
public void UpdateModelWithImportedData_CalculationWithOutputAssignedRemovedSoilModelAndProfile_CalculationUpdatedAndCalculationAndInputReturned()
{
// Setup
PipingStochasticSoilModel existingModel = PipingStochasticSoilModelTestFactory.CreatePipingStochasticSoilModel();
var calculation = new SemiProbabilisticPipingCalculationScenario
{
InputParameters =
{
StochasticSoilModel = existingModel,
StochasticSoilProfile = existingModel.StochasticSoilProfiles.First()
},
Output = new SemiProbabilisticPipingOutput(new SemiProbabilisticPipingOutput.ConstructionProperties())
};
var failureMechanism = new PipingFailureMechanism();
failureMechanism.CalculationsGroup.Children.Add(calculation);
var strategy = new PipingStochasticSoilModelReplaceDataStrategy(failureMechanism);
var targetCollection = new PipingStochasticSoilModelCollection();
targetCollection.AddRange(new[]
{
existingModel
}, sourceFilePath);
// Call
IEnumerable <IObservable> affectedObjects = strategy.UpdateModelWithImportedData(new List <PipingStochasticSoilModel>(), sourceFilePath).ToArray();
// Assert
Assert.IsFalse(calculation.HasOutput);
Assert.IsNull(calculation.InputParameters.StochasticSoilModel);
Assert.IsNull(calculation.InputParameters.StochasticSoilProfile);
CollectionAssert.AreEquivalent(new IObservable[]
{
calculation,
calculation.InputParameters,
failureMechanism.StochasticSoilModels
}, affectedObjects);
}
protected override void PrefillComboBoxListItemsAtColumnLevel()
{
base.PrefillComboBoxListItemsAtColumnLevel();
var stochasticSoilModelColumn = (DataGridViewComboBoxColumn)DataGridViewControl.GetColumnFromIndex(stochasticSoilModelColumnIndex);
var stochasticSoilProfileColumn = (DataGridViewComboBoxColumn)DataGridViewControl.GetColumnFromIndex(stochasticSoilProfileColumnIndex);
// Need to prefill for all possible data in order to guarantee 'combo box' columns
// do not generate errors when their cell value is not present in the list of available
// items.
using (new SuspendDataGridViewColumnResizes(stochasticSoilModelColumn))
{
PipingStochasticSoilModelCollection stochasticSoilModels = FailureMechanism.StochasticSoilModels;
SetItemsOnObjectCollection(stochasticSoilModelColumn.Items, GetStochasticSoilModelsDataSource(stochasticSoilModels).ToArray());
}
using (new SuspendDataGridViewColumnResizes(stochasticSoilProfileColumn))
{
IEnumerable <PipingStochasticSoilProfile> pipingSoilProfiles = GetPipingStochasticSoilProfilesFromStochasticSoilModels();
SetItemsOnObjectCollection(stochasticSoilProfileColumn.Items, GetSoilProfilesDataSource(pipingSoilProfiles).ToArray());
}
}
public void IsEnabled_SoilModelCollectionSourcePathSet_ReturnTrue()
{
// Setup
var mocks = new MockRepository();
var assessmentSection = mocks.Stub <IAssessmentSection>();
mocks.ReplayAll();
var failureMechanism = new PipingFailureMechanism();
var stochasticSoilModel = new PipingStochasticSoilModelCollection();
stochasticSoilModel.AddRange(Enumerable.Empty <PipingStochasticSoilModel>(), "some/path");
var context = new PipingStochasticSoilModelCollectionContext(stochasticSoilModel, failureMechanism, assessmentSection);
// Call
bool isEnabled = updateInfo.IsEnabled(context);
// Assert
Assert.IsTrue(isEnabled);
mocks.VerifyAll();
}
public void CreateInstance_WithContext_NewPropertiesWithInputContextAsData()
{
// Setup
var mocks = new MockRepository();
var assessmentSection = mocks.Stub <IAssessmentSection>();
mocks.ReplayAll();
var failureMechanism = new PipingFailureMechanism();
var collection = new PipingStochasticSoilModelCollection();
var context = new PipingStochasticSoilModelCollectionContext(collection, failureMechanism, assessmentSection);
// Call
IObjectProperties objectProperties = info.CreateInstance(context);
// Assert
Assert.IsInstanceOf <PipingStochasticSoilModelCollectionProperties>(objectProperties);
Assert.AreSame(collection, objectProperties.Data);
mocks.VerifyAll();
}
public void Constructor_WithData_PropertiesHaveExpectedAttributesValues()
{
// Setup
var collection = new PipingStochasticSoilModelCollection();
// Call
var properties = new PipingStochasticSoilModelCollectionProperties(collection);
// Assert
PropertyDescriptorCollection dynamicProperties = PropertiesTestHelper.GetAllVisiblePropertyDescriptors(properties);
Assert.AreEqual(1, dynamicProperties.Count);
PropertyDescriptor stochasticSoilModelSourcePathProperty = dynamicProperties[0];
Assert.IsNotNull(stochasticSoilModelSourcePathProperty);
Assert.IsTrue(stochasticSoilModelSourcePathProperty.IsReadOnly);
Assert.AreEqual("Algemeen", stochasticSoilModelSourcePathProperty.Category);
Assert.AreEqual("Bronlocatie", stochasticSoilModelSourcePathProperty.DisplayName);
Assert.AreEqual(
"De locatie van het bestand waaruit de stochastische ondergrondmodellen zijn geïmporteerd.",
stochasticSoilModelSourcePathProperty.Description);
}
private void SetStochasticSoilModelsMapData()
{
PipingStochasticSoilModelCollection stochasticSoilModels = FailureMechanism.StochasticSoilModels;
stochasticSoilModelsMapData.Features = PipingMapDataFeaturesFactory.CreateStochasticSoilModelFeatures(stochasticSoilModels.ToArray());
}
public void UpdateModelWithImportedData_ProfilesAssignedToCalculationsOneWithRemovedProfile_OnlyCalculationWithRemovedProfileUpdated()
{
// Setup
const string modelsName = "same model";
PipingStochasticSoilModel existingModel = PipingStochasticSoilModelTestFactory.CreatePipingStochasticSoilModel(modelsName, new[]
{
CreateStochasticSoilProfile("Removed Profile"),
CreateStochasticSoilProfile("Unaffected Profile")
});
var failureMechanism = new PipingFailureMechanism();
PipingStochasticSoilModelCollection targetCollection = failureMechanism.StochasticSoilModels;
targetCollection.AddRange(new[]
{
existingModel
}, sourceFilePath);
PipingStochasticSoilProfile removedProfile = existingModel.StochasticSoilProfiles.ElementAt(0);
PipingStochasticSoilProfile unaffectedProfile = existingModel.StochasticSoilProfiles.ElementAt(1);
PipingStochasticSoilModel readModel = PipingStochasticSoilModelTestFactory.CreatePipingStochasticSoilModel(modelsName, new[]
{
CreateStochasticSoilProfile("Unaffected Profile")
});
var calculationWithRemovedProfile = new SemiProbabilisticPipingCalculationScenario();
calculationWithRemovedProfile.InputParameters.StochasticSoilModel = existingModel;
calculationWithRemovedProfile.InputParameters.StochasticSoilProfile = removedProfile;
calculationWithRemovedProfile.Output = new SemiProbabilisticPipingOutput(new SemiProbabilisticPipingOutput.ConstructionProperties());
var calculationWithNotUpdatedProfile = new SemiProbabilisticPipingCalculationScenario();
calculationWithNotUpdatedProfile.InputParameters.StochasticSoilModel = existingModel;
calculationWithNotUpdatedProfile.InputParameters.StochasticSoilProfile = unaffectedProfile;
calculationWithNotUpdatedProfile.Output = new SemiProbabilisticPipingOutput(new SemiProbabilisticPipingOutput.ConstructionProperties());
failureMechanism.CalculationsGroup.Children.Add(calculationWithNotUpdatedProfile);
failureMechanism.CalculationsGroup.Children.Add(calculationWithRemovedProfile);
var strategy = new PipingStochasticSoilModelUpdateDataStrategy(failureMechanism);
// Call
IEnumerable <IObservable> affectedObjects = strategy.UpdateModelWithImportedData(new[]
{
readModel
}, sourceFilePath).ToArray();
// Assert
PipingStochasticSoilModel firstSoilModel = targetCollection[0];
Assert.AreSame(existingModel, firstSoilModel);
Assert.AreEqual(1, firstSoilModel.StochasticSoilProfiles.Count());
Assert.AreSame(unaffectedProfile, firstSoilModel.StochasticSoilProfiles.First());
Assert.IsFalse(calculationWithRemovedProfile.HasOutput);
Assert.IsNull(calculationWithRemovedProfile.InputParameters.StochasticSoilProfile);
Assert.IsTrue(calculationWithNotUpdatedProfile.HasOutput);
Assert.AreSame(unaffectedProfile, calculationWithNotUpdatedProfile.InputParameters.StochasticSoilProfile);
CollectionAssert.AreEquivalent(new IObservable[]
{
targetCollection,
firstSoilModel,
calculationWithRemovedProfile,
calculationWithRemovedProfile.InputParameters
}, affectedObjects);
}
public void PipingCalculationsView_DataImportedOrChanged_ChangesCorrectlyObservedAndSynced()
{
// Setup
using (var form = new Form())
{
var assessmentSection = new AssessmentSection(AssessmentSectionComposition.Dike);
PipingFailureMechanism failureMechanism = assessmentSection.Piping;
// Show the view
var pipingCalculationsView = new PipingCalculationsView(failureMechanism.CalculationsGroup, failureMechanism, assessmentSection);
form.Controls.Add(pipingCalculationsView);
form.Show();
// Obtain some relevant controls
var dataGridView = (DataGridView) new ControlTester("dataGridView").TheObject;
// Import failure mechanism sections
DataImportHelper.ImportReferenceLine(assessmentSection);
DataImportHelper.ImportFailureMechanismSections(assessmentSection, failureMechanism);
// Import surface lines
DataImportHelper.ImportPipingSurfaceLines(assessmentSection);
// Setup some calculations
var calculation1 = new SemiProbabilisticPipingCalculationScenario
{
InputParameters =
{
SurfaceLine = failureMechanism.SurfaceLines.First(sl => sl.Name == "PK001_0001")
}
};
var calculation2 = new ProbabilisticPipingCalculationScenario
{
InputParameters =
{
SurfaceLine = failureMechanism.SurfaceLines.First(sl => sl.Name == "PK001_0001")
}
};
// Add a piping calculation and ensure it is shown in the data grid view
failureMechanism.CalculationsGroup.Children.Add(calculation1);
failureMechanism.CalculationsGroup.NotifyObservers();
Assert.AreEqual(1, dataGridView.Rows.Count);
// Import soil models and profiles and ensure the corresponding combobox items are updated
DataImportHelper.ImportPipingStochasticSoilModels(assessmentSection);
PipingStochasticSoilModelCollection stochasticSoilModelCollection = failureMechanism.StochasticSoilModels;
calculation1.InputParameters.StochasticSoilModel = stochasticSoilModelCollection.First(sl => sl.Name == "PK001_0001_Piping");
Assert.AreEqual(2, ((DataGridViewComboBoxCell)dataGridView.Rows[0].Cells[stochasticSoilModelsColumnIndex]).Items.Count);
Assert.AreEqual("PK001_0001_Piping", dataGridView.Rows[0].Cells[stochasticSoilModelsColumnIndex].FormattedValue);
Assert.AreEqual(1, ((DataGridViewComboBoxCell)dataGridView.Rows[0].Cells[stochasticSoilProfilesColumnIndex]).Items.Count);
Assert.AreEqual("<selecteer>", dataGridView.Rows[0].Cells[stochasticSoilProfilesColumnIndex].FormattedValue);
// Import hydraulic boundary locations and ensure the corresponding combobox items are updated
DataImportHelper.ImportHydraulicBoundaryDatabase(assessmentSection);
assessmentSection.HydraulicBoundaryDatabase.Locations.NotifyObservers();
Assert.AreEqual(19, ((DataGridViewComboBoxCell)dataGridView.Rows[0].Cells[hydraulicBoundaryLocationsColumnIndex]).Items.Count);
// Add group and ensure the data grid view is not changed
var nestedPipingCalculationGroup = new CalculationGroup();
failureMechanism.CalculationsGroup.Children.Add(nestedPipingCalculationGroup);
failureMechanism.CalculationsGroup.NotifyObservers();
Assert.AreEqual(1, dataGridView.Rows.Count);
// Add another, nested calculation and ensure the data grid view is updated
nestedPipingCalculationGroup.Children.Add(calculation2);
nestedPipingCalculationGroup.NotifyObservers();
Assert.AreEqual(2, dataGridView.Rows.Count);
// Change the name of the first calculation and ensure the data grid view is updated
calculation1.Name = "New name";
calculation1.NotifyObservers();
Assert.AreEqual("New name", dataGridView.Rows[0].Cells[nameColumnIndex].FormattedValue);
// Change an input parameter of the second calculation and ensure the data grid view is updated
var exitPointL = new RoundedDouble(2, 111.11);
calculation2.InputParameters.ExitPointL = exitPointL;
calculation2.InputParameters.NotifyObservers();
Assert.AreEqual(exitPointL.ToString(), dataGridView.Rows[1].Cells[exitPointLColumnIndex].FormattedValue);
// Add another calculation and assign all soil models
var pipingCalculation3 = new SemiProbabilisticPipingCalculationScenario();
failureMechanism.CalculationsGroup.Children.Add(pipingCalculation3);
failureMechanism.CalculationsGroup.NotifyObservers();
pipingCalculation3.InputParameters.SurfaceLine = failureMechanism.SurfaceLines.First(sl => sl.Name == "PK001_0001");
pipingCalculation3.InputParameters.NotifyObservers();
Assert.AreEqual(3, dataGridView.Rows.Count);
calculation1.InputParameters.StochasticSoilModel = stochasticSoilModelCollection[0];
calculation1.InputParameters.StochasticSoilProfile = stochasticSoilModelCollection[0].StochasticSoilProfiles.First();
calculation1.InputParameters.NotifyObservers();
Assert.AreEqual("PK001_0001_Piping", dataGridView.Rows[0].Cells[stochasticSoilModelsColumnIndex].FormattedValue);
Assert.AreEqual("W1-6_0_1D1", dataGridView.Rows[0].Cells[stochasticSoilProfilesColumnIndex].FormattedValue);
Assert.AreEqual(GetFormattedProbabilityValue(100), dataGridView.Rows[0].Cells[stochasticSoilProfilesProbabilityColumnIndex].FormattedValue);
calculation2.InputParameters.SurfaceLine = failureMechanism.SurfaceLines.First(sl => sl.Name == "PK001_0002");
calculation2.InputParameters.StochasticSoilModel = stochasticSoilModelCollection[1];
calculation2.InputParameters.StochasticSoilProfile = stochasticSoilModelCollection[1].StochasticSoilProfiles.First();
calculation2.InputParameters.NotifyObservers();
Assert.AreEqual("PK001_0002_Piping", dataGridView.Rows[1].Cells[stochasticSoilModelsColumnIndex].FormattedValue);
Assert.AreEqual("W1-6_4_1D1", dataGridView.Rows[1].Cells[stochasticSoilProfilesColumnIndex].FormattedValue);
Assert.AreEqual(GetFormattedProbabilityValue(100), dataGridView.Rows[1].Cells[stochasticSoilProfilesProbabilityColumnIndex].FormattedValue);
pipingCalculation3.InputParameters.SurfaceLine = failureMechanism.SurfaceLines.First(sl => sl.Name == "PK001_0003");
pipingCalculation3.InputParameters.StochasticSoilModel = stochasticSoilModelCollection[2];
pipingCalculation3.InputParameters.StochasticSoilProfile = stochasticSoilModelCollection[2].StochasticSoilProfiles.First();
pipingCalculation3.InputParameters.NotifyObservers();
Assert.AreEqual("PK001_0003_Piping", dataGridView.Rows[2].Cells[stochasticSoilModelsColumnIndex].FormattedValue);
Assert.AreEqual("W1-7_0_1D1", dataGridView.Rows[2].Cells[stochasticSoilProfilesColumnIndex].FormattedValue);
Assert.AreEqual(GetFormattedProbabilityValue(100), dataGridView.Rows[2].Cells[stochasticSoilProfilesProbabilityColumnIndex].FormattedValue);
// Update stochastic soil models
DataUpdateHelper.UpdatePipingStochasticSoilModels(assessmentSection);
Assert.AreEqual("PK001_0001_Piping", dataGridView.Rows[0].Cells[stochasticSoilModelsColumnIndex].FormattedValue);
Assert.AreEqual("W1-6_0_1D1", dataGridView.Rows[0].Cells[stochasticSoilProfilesColumnIndex].FormattedValue);
Assert.AreEqual(GetFormattedProbabilityValue(50), dataGridView.Rows[0].Cells[stochasticSoilProfilesProbabilityColumnIndex].FormattedValue);
Assert.AreEqual("PK001_0002_Piping", dataGridView.Rows[1].Cells[stochasticSoilModelsColumnIndex].FormattedValue);
Assert.AreEqual("<selecteer>", dataGridView.Rows[1].Cells[stochasticSoilProfilesColumnIndex].FormattedValue);
Assert.AreEqual(GetFormattedProbabilityValue(0), dataGridView.Rows[1].Cells[stochasticSoilProfilesProbabilityColumnIndex].FormattedValue);
Assert.AreEqual("PK001_0003_Piping", dataGridView.Rows[2].Cells[stochasticSoilModelsColumnIndex].FormattedValue);
Assert.AreEqual("W1-7_0_1D1", dataGridView.Rows[2].Cells[stochasticSoilProfilesColumnIndex].FormattedValue);
Assert.AreEqual(GetFormattedProbabilityValue(100), dataGridView.Rows[2].Cells[stochasticSoilProfilesProbabilityColumnIndex].FormattedValue);
}
}
