public void ChildNodeObjects_Always_ReturnsChildrenOfData()
{
// Setup
var assessmentSection = mocks.Stub <IAssessmentSection>();
mocks.ReplayAll();
PipingStochasticSoilModel stochasticSoilModel = PipingStochasticSoilModelTestFactory.CreatePipingStochasticSoilModel("Name", new[]
{
new PipingStochasticSoilProfile(0.5, PipingSoilProfileTestFactory.CreatePipingSoilProfile()),
new PipingStochasticSoilProfile(0.5, PipingSoilProfileTestFactory.CreatePipingSoilProfile())
});
var failureMechanism = new PipingFailureMechanism();
var stochasticSoilModelCollectionContext = new PipingStochasticSoilModelCollectionContext(
failureMechanism.StochasticSoilModels,
failureMechanism,
assessmentSection);
failureMechanism.StochasticSoilModels.AddRange(new[]
{
stochasticSoilModel
}, "path");
// Call
object[] objects = info.ChildNodeObjects(stochasticSoilModelCollectionContext);
// Assert
CollectionAssert.AreEqual(new[]
{
stochasticSoilModel
}, objects);
}
/// <summary>
/// Removes a given <see cref="PipingStochasticSoilModel"/> from the <see cref="PipingFailureMechanism"/>
/// and clears all data that depends on it, either directly or indirectly.
/// </summary>
/// <param name="failureMechanism">The failure mechanism containing <paramref name="soilModel"/>.</param>
/// <param name="soilModel">The soil model residing in <paramref name="failureMechanism"/>
/// that should be removed.</param>
/// <returns>All observable objects affected by this method.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="failureMechanism"/>
/// or <paramref name="soilModel"/> is <c>null</c>.</exception>
public static IEnumerable <IObservable> RemoveStochasticSoilModel(PipingFailureMechanism failureMechanism,
PipingStochasticSoilModel soilModel)
{
if (failureMechanism == null)
{
throw new ArgumentNullException(nameof(failureMechanism));
}
if (soilModel == null)
{
throw new ArgumentNullException(nameof(soilModel));
}
var changedObservables = new List <IObservable>();
IEnumerable <IPipingCalculationScenario <PipingInput> > pipingCalculations =
failureMechanism.Calculations
.Cast <IPipingCalculationScenario <PipingInput> >()
.Where(pcs => ReferenceEquals(pcs.InputParameters.StochasticSoilModel, soilModel));
foreach (IPipingCalculationScenario <PipingInput> pipingCalculation in pipingCalculations)
{
changedObservables.AddRange(RiskeerCommonDataSynchronizationService.ClearCalculationOutput(pipingCalculation));
changedObservables.AddRange(ClearStochasticSoilModel(pipingCalculation.InputParameters));
}
failureMechanism.StochasticSoilModels.Remove(soilModel);
changedObservables.Add(failureMechanism.StochasticSoilModels);
return(changedObservables);
}
public void Update_ModelWithAddedProfile_ProfileAdded()
{
// Setup
PipingStochasticSoilModel model = CreateValidModel(new[]
{
CreateStochasticSoilProfile()
});
var expectedAddedProfile = new PipingStochasticSoilProfile(0.2, PipingSoilProfileTestFactory.CreatePipingSoilProfile());
PipingStochasticSoilModel otherModel = CreateValidModel(new[]
{
expectedAddedProfile,
CreateStochasticSoilProfile()
});
// Call
PipingStochasticSoilModelProfileDifference difference = model.Update(otherModel);
// Assert
Assert.AreEqual(2, otherModel.StochasticSoilProfiles.Count());
Assert.AreEqual(expectedAddedProfile, otherModel.StochasticSoilProfiles.First());
CollectionAssert.AreEqual(new[]
{
expectedAddedProfile
}, difference.AddedProfiles);
CollectionAssert.IsEmpty(difference.UpdatedProfiles);
CollectionAssert.IsEmpty(difference.RemovedProfiles);
}
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);
}
/// <summary>
/// Creates a <see cref="StochasticSoilModelEntity"/> based on the information of the <see cref="PipingStochasticSoilModel"/>.
/// </summary>
/// <param name="model">The model to create a database entity for.</param>
/// <param name="registry">The object keeping track of create operations.</param>
/// <param name="order">Index at which this instance resides inside its parent container.</param>
/// <returns>A new <see cref="StochasticSoilModelEntity"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when any input parameter is <c>null</c>.</exception>
internal static StochasticSoilModelEntity Create(this PipingStochasticSoilModel model,
PersistenceRegistry registry,
int order)
{
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
if (registry == null)
{
throw new ArgumentNullException(nameof(registry));
}
if (registry.Contains(model))
{
return(registry.Get(model));
}
var entity = new StochasticSoilModelEntity
{
Name = model.Name.DeepClone(),
StochasticSoilModelSegmentPointXml = new Point2DCollectionXmlSerializer().ToXml(model.Geometry),
Order = order
};
AddEntitiesForStochasticSoilProfiles(model, registry, entity);
registry.Register(entity, model);
return(entity);
}
public void Constructor_ValidParameters_ExpectedValues()
{
// Setup
const string name = "name";
var geometry = new[]
{
new Point2D(1, 1)
};
PipingStochasticSoilProfile[] stochasticSoilProfiles =
{
CreateStochasticSoilProfile()
};
// Call
var model = new PipingStochasticSoilModel(name, geometry, stochasticSoilProfiles);
// Assert
Assert.IsInstanceOf <Observable>(model);
Assert.IsInstanceOf <IMechanismStochasticSoilModel>(model);
Assert.AreEqual(name, model.Name);
Assert.AreSame(geometry, model.Geometry);
CollectionAssert.AreEqual(stochasticSoilProfiles, model.StochasticSoilProfiles);
Assert.AreEqual(name, model.ToString());
}
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 SemiProbabilisticPipingCalculationEntity
{
PipingStochasticSoilProfileEntity = stochasticSoilProfileEntity,
EntryPointL = 1,
ExitPointL = 2,
DampingFactorExitMean = 1,
ScenarioContribution = 0
};
var collector = new ReadConversionCollector();
collector.Read(stochasticSoilProfileEntity, stochasticSoilProfile);
collector.Read(stochasticSoilModelEntity, stochasticSoilModel);
// Call
SemiProbabilisticPipingCalculationScenario calculation = entity.Read(collector);
// Assert
Assert.AreSame(stochasticSoilProfile, calculation.InputParameters.StochasticSoilProfile);
Assert.AreSame(stochasticSoilModel, calculation.InputParameters.StochasticSoilModel);
}
public void Update_ModelWithUpdatedProfile_ProfileUpdated()
{
// Setup
const string profileName = "A";
var expectedUpdatedProfile = new PipingStochasticSoilProfile(
0.2,
new PipingSoilProfile(profileName, -2, CreateLayers(), SoilProfileType.SoilProfile1D));
PipingStochasticSoilModel model = CreateValidModel(new[]
{
expectedUpdatedProfile
});
PipingStochasticSoilModel otherModel = CreateValidModel(new[]
{
new PipingStochasticSoilProfile(0.2,
new PipingSoilProfile(profileName, -1, CreateLayers(), SoilProfileType.SoilProfile1D))
});
// Call
PipingStochasticSoilModelProfileDifference difference = model.Update(otherModel);
// Assert
Assert.AreEqual(1, otherModel.StochasticSoilProfiles.Count());
Assert.AreEqual(expectedUpdatedProfile, otherModel.StochasticSoilProfiles.First());
CollectionAssert.IsEmpty(difference.AddedProfiles);
CollectionAssert.AreEqual(new[]
{
expectedUpdatedProfile
}, difference.UpdatedProfiles);
CollectionAssert.IsEmpty(difference.RemovedProfiles);
}
public void ReadAsPipingStochasticSoilModel_SameStochasticSoilModelEntityMultipleTimes_ReturnSameStochasticSoilModel()
{
// Setup
var random = new Random(21);
var geometry = new[]
{
new Point2D(random.NextDouble(), random.NextDouble())
};
var entity = new StochasticSoilModelEntity
{
Name = "StochasticSoilModel",
StochasticSoilModelSegmentPointXml = new Point2DCollectionXmlSerializer().ToXml(geometry),
PipingStochasticSoilProfileEntities =
{
PipingStochasticSoilProfileEntityTestFactory.CreateStochasticSoilProfileEntity()
}
};
var collector = new ReadConversionCollector();
// Call
PipingStochasticSoilModel soilModel1 = entity.ReadAsPipingStochasticSoilModel(collector);
PipingStochasticSoilModel soilModel2 = entity.ReadAsPipingStochasticSoilModel(collector);
// Assert
Assert.AreSame(soilModel1, soilModel2);
}
/// <summary>
/// Reads the <see cref="StochasticSoilModelEntity"/> and use the information to construct
/// a <see cref="PipingStochasticSoilModel"/>.
/// </summary>
/// <param name="entity">The <see cref="StochasticSoilModelEntity"/> to create <see cref="PipingStochasticSoilModel"/> for.</param>
/// <param name="collector">The object keeping track of read operations.</param>
/// <returns>A new <see cref="PipingStochasticSoilModel"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when any input parameter is <c>null</c>.</exception>
/// <exception cref="ArgumentException">Thrown when <see cref="StochasticSoilModelEntity.StochasticSoilModelSegmentPointXml"/>
/// of <paramref name="entity"/> is empty.</exception>
public static PipingStochasticSoilModel ReadAsPipingStochasticSoilModel(this StochasticSoilModelEntity entity,
ReadConversionCollector collector)
{
if (entity == null)
{
throw new ArgumentNullException(nameof(entity));
}
if (collector == null)
{
throw new ArgumentNullException(nameof(collector));
}
if (collector.ContainsPipingStochasticSoilModel(entity))
{
return(collector.GetPipingStochasticSoilModel(entity));
}
Point2D[] geometry = ReadSegmentPoints(entity.StochasticSoilModelSegmentPointXml).ToArray();
PipingStochasticSoilProfile[] stochasticSoilProfiles = ReadPipingStochasticSoilProfiles(entity, collector).ToArray();
var model = new PipingStochasticSoilModel(entity.Name, geometry, stochasticSoilProfiles);
collector.Read(entity, model);
return(model);
}
public void Update_ModelWithRemovedProfileSameNameOtherType_ProfileRemoved()
{
// Setup
const string profileName = "A";
var soilProfile = new PipingSoilProfile(profileName, -2, CreateLayers(), SoilProfileType.SoilProfile1D);
var expectedRemovedProfile = new PipingStochasticSoilProfile(0.2, soilProfile);
var newProfile = new PipingStochasticSoilProfile(
0.2,
new PipingSoilProfile(profileName, -2, CreateLayers(), SoilProfileType.SoilProfile2D));
PipingStochasticSoilModel model = CreateValidModel(new[]
{
CreateStochasticSoilProfile(),
expectedRemovedProfile
});
PipingStochasticSoilModel otherModel = CreateValidModel(new[]
{
CreateStochasticSoilProfile(),
newProfile
});
// Call
PipingStochasticSoilModelProfileDifference difference = model.Update(otherModel);
// Assert
CollectionAssert.AreEqual(new[]
{
newProfile
}, difference.AddedProfiles);
CollectionAssert.IsEmpty(difference.UpdatedProfiles);
CollectionAssert.AreEqual(new[]
{
expectedRemovedProfile
}, difference.RemovedProfiles);
}
public void ContextMenuStrip_Always_CallsBuilder()
{
// Setup
PipingStochasticSoilModel model = PipingStochasticSoilModelTestFactory.CreatePipingStochasticSoilModel();
var mocks = new MockRepository();
var menuBuilder = mocks.StrictMock <IContextMenuBuilder>();
using (mocks.Ordered())
{
menuBuilder.Expect(mb => mb.AddCollapseAllItem()).Return(menuBuilder);
menuBuilder.Expect(mb => mb.AddExpandAllItem()).Return(menuBuilder);
menuBuilder.Expect(mb => mb.AddSeparator()).Return(menuBuilder);
menuBuilder.Expect(mb => mb.AddPropertiesItem()).Return(menuBuilder);
menuBuilder.Expect(mb => mb.Build()).Return(null);
}
using (var treeViewControl = new TreeViewControl())
{
var gui = mocks.Stub <IGui>();
gui.Stub(g => g.Get(model, treeViewControl)).Return(menuBuilder);
mocks.ReplayAll();
plugin.Gui = gui;
// Call
info.ContextMenuStrip(model, null, treeViewControl);
}
// Assert
mocks.VerifyAll();
}
public void UpdateModelWithImportedData_WithCurrentModelAndImportedModel_ModelReplaced()
{
// Setup
PipingStochasticSoilModel existingModel = PipingStochasticSoilModelTestFactory.CreatePipingStochasticSoilModel("existing");
var pipingFailureMechanism = new PipingFailureMechanism();
pipingFailureMechanism.StochasticSoilModels.AddRange(new[]
{
existingModel
}, sourceFilePath);
var strategy = new PipingStochasticSoilModelReplaceDataStrategy(pipingFailureMechanism);
PipingStochasticSoilModel readModel = PipingStochasticSoilModelTestFactory.CreatePipingStochasticSoilModel("read");
// Call
IEnumerable <IObservable> affectedObjects = strategy.UpdateModelWithImportedData(new[]
{
readModel
}, sourceFilePath);
// Assert
Assert.AreSame(readModel, pipingFailureMechanism.StochasticSoilModels[0]);
CollectionAssert.AreEqual(new[]
{
pipingFailureMechanism.StochasticSoilModels
}, affectedObjects);
}
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 GivenViewWithStochasticSoilModels_WhenStochasticSoilModelsUpdatedAndNotified_ThenMapDataUpdated()
{
// Given
var failureMechanism = new PipingFailureMechanism();
PipingFailureMechanismView view = CreateView(failureMechanism, new AssessmentSectionStub());
IMapControl map = ((RiskeerMapControl)view.Controls[0]).MapControl;
PipingStochasticSoilModel stochasticSoilModel = PipingStochasticSoilModelTestFactory.CreatePipingStochasticSoilModel("", new[]
{
new Point2D(1, 2),
new Point2D(1, 2)
});
var stochasticSoilModelMapData = (MapLineData)map.Data.Collection.ElementAt(stochasticSoilModelsIndex);
var mocks = new MockRepository();
IObserver[] observers = AttachMapDataObservers(mocks, map.Data.Collection);
observers[stochasticSoilModelsIndex].Expect(obs => obs.UpdateObserver());
mocks.ReplayAll();
// When
failureMechanism.StochasticSoilModels.AddRange(new[]
{
stochasticSoilModel
}, "path");
failureMechanism.StochasticSoilModels.NotifyObservers();
// Then
AssertStochasticSoilModelsMapData(failureMechanism.StochasticSoilModels, stochasticSoilModelMapData);
mocks.VerifyAll();
}
/// <summary>
/// Assigns the stochastic soil model.
/// </summary>
/// <param name="calculationConfiguration">The calculation read from the imported file.</param>
/// <param name="pipingCalculation">The calculation to configure.</param>
/// <returns><c>false</c> when
/// <list type="bullet">
/// <item>the <paramref name="calculationConfiguration"/> has a <see cref="PipingStochasticSoilModel"/> set
/// which is not available in the failure mechanism.</item>
/// <item>The <see cref="PipingStochasticSoilModel"/> does not intersect with the <see cref="PipingSurfaceLine"/>
/// when this is set.</item>
/// </list>
/// <c>true</c> otherwise.</returns>
private bool TrySetStochasticSoilModel(PipingCalculationConfiguration calculationConfiguration,
IPipingCalculationScenario <PipingInput> pipingCalculation)
{
if (calculationConfiguration.StochasticSoilModelName != null)
{
PipingStochasticSoilModel soilModel = failureMechanism.StochasticSoilModels
.FirstOrDefault(ssm => ssm.Name == calculationConfiguration.StochasticSoilModelName);
if (soilModel == null)
{
Log.LogCalculationConversionError(string.Format(
Resources.PipingCalculationConfigurationImporter_ReadStochasticSoilModel_Stochastische_soil_model_0_does_not_exist,
calculationConfiguration.StochasticSoilModelName),
pipingCalculation.Name);
return(false);
}
if (pipingCalculation.InputParameters.SurfaceLine != null &&
!soilModel.IntersectsWithSurfaceLineGeometry(pipingCalculation.InputParameters.SurfaceLine))
{
Log.LogCalculationConversionError(string.Format(
Resources.PipingCalculationConfigurationImporter_ReadStochasticSoilModel_Stochastische_soil_model_0_does_not_intersect_with_surfaceLine_1,
calculationConfiguration.StochasticSoilModelName,
calculationConfiguration.SurfaceLineName),
pipingCalculation.Name);
return(false);
}
pipingCalculation.InputParameters.StochasticSoilModel = soilModel;
}
return(true);
}
public void Update_ModelWithUpdatedProperties_PropertiesUpdated()
{
// Setup
var model = new PipingStochasticSoilModel("name", new[]
{
new Point2D(1, 2),
new Point2D(4, 5)
}, new[]
{
CreateStochasticSoilProfile()
});
const string expectedName = "otherName";
var expectedGeometry = new[]
{
new Point2D(4, 2)
};
var otherModel = new PipingStochasticSoilModel(expectedName, expectedGeometry, new[]
{
CreateStochasticSoilProfile()
});
// Call
PipingStochasticSoilModelProfileDifference difference = model.Update(otherModel);
// Assert
Assert.AreEqual(expectedName, model.Name);
CollectionAssert.AreEqual(expectedGeometry, model.Geometry);
CollectionAssert.IsEmpty(difference.AddedProfiles);
CollectionAssert.IsEmpty(difference.UpdatedProfiles);
CollectionAssert.IsEmpty(difference.RemovedProfiles);
}
public void Update_ModelsWithAddedProfilesWithSameNames_ThrowsInvalidOperationException()
{
// Setup
const string profileName = "Name of the profile";
var addedProfile = new PipingStochasticSoilProfile(0.2, PipingSoilProfileTestFactory.CreatePipingSoilProfile(profileName));
PipingStochasticSoilModel otherModel = CreateValidModel(new[]
{
addedProfile
});
PipingSoilProfile soilProfile = PipingSoilProfileTestFactory.CreatePipingSoilProfile(profileName);
var existingStochasticSoilProfileOne = new PipingStochasticSoilProfile(0.2, soilProfile);
var existingStochasticSoilProfileTwo = new PipingStochasticSoilProfile(0.3, soilProfile);
PipingStochasticSoilModel model = CreateValidModel(new[]
{
existingStochasticSoilProfileOne,
existingStochasticSoilProfileTwo
});
// Call
TestDelegate call = () => model.Update(otherModel);
// Assert
Assert.Throws <InvalidOperationException>(call);
Assert.AreEqual(1, otherModel.StochasticSoilProfiles.Count());
Assert.AreEqual(addedProfile, otherModel.StochasticSoilProfiles.First());
Assert.AreEqual(2, model.StochasticSoilProfiles.Count());
CollectionAssert.AreEqual(new[]
{
existingStochasticSoilProfileOne,
existingStochasticSoilProfileTwo
}, model.StochasticSoilProfiles);
}
public void ReadAsPipingStochasticSoilModel_WithValidEntity_ReturnsNewStochasticSoilModelWithPropertiesSet()
{
// Setup
var random = new Random(21);
var geometry = new[]
{
new Point2D(random.NextDouble(), random.NextDouble()),
new Point2D(random.NextDouble(), random.NextDouble())
};
var entity = new StochasticSoilModelEntity
{
Name = "StochasticSoilModel",
StochasticSoilModelSegmentPointXml = new Point2DCollectionXmlSerializer().ToXml(geometry),
PipingStochasticSoilProfileEntities =
{
new PipingStochasticSoilProfileEntity
{
PipingSoilProfileEntity = new PipingSoilProfileEntity
{
PipingSoilLayerEntities =
{
new PipingSoilLayerEntity()
},
Name = "A"
},
Order = 1
},
new PipingStochasticSoilProfileEntity
{
PipingSoilProfileEntity = new PipingSoilProfileEntity
{
PipingSoilLayerEntities =
{
new PipingSoilLayerEntity()
},
Name = "B"
},
Order = 0
}
}
};
var collector = new ReadConversionCollector();
// Call
PipingStochasticSoilModel model = entity.ReadAsPipingStochasticSoilModel(collector);
// Assert
Assert.IsNotNull(model);
Assert.AreEqual(entity.Name, model.Name);
CollectionAssert.AreEqual(geometry, model.Geometry);
Assert.AreEqual(entity.PipingStochasticSoilProfileEntities.Count, model.StochasticSoilProfiles.Count());
CollectionAssert.AreEqual(new[]
{
"B",
"A"
}, model.StochasticSoilProfiles.Select(ssp => ssp.SoilProfile.Name));
}
public void Update_WithOtherModel_PropertiesUpdated()
{
// Setup
const string equalProfileName = "nameA";
var stochasticProfileA = new PipingStochasticSoilProfile(0.5, PipingSoilProfileTestFactory.CreatePipingSoilProfile(equalProfileName));
var stochasticProfileB = new PipingStochasticSoilProfile(0.5, PipingSoilProfileTestFactory.CreatePipingSoilProfile("nameB"));
PipingStochasticSoilModel model = CreateValidModel(new[]
{
stochasticProfileA,
stochasticProfileB
});
const string otherName = "other name";
var otherGeometry = new[]
{
new Point2D(2, 0),
new Point2D(3, 0)
};
var otherStochasticProfileA = new PipingStochasticSoilProfile(
0.7, new PipingSoilProfile(equalProfileName, -1, new[]
{
new PipingSoilLayer(0)
}, SoilProfileType.SoilProfile1D));
var otherStochasticProfileB = new PipingStochasticSoilProfile(0.3, PipingSoilProfileTestFactory.CreatePipingSoilProfile("other profile name"));
var otherModel = new PipingStochasticSoilModel(otherName, otherGeometry, new[]
{
otherStochasticProfileA,
otherStochasticProfileB
});
// Call
PipingStochasticSoilModelProfileDifference difference = model.Update(otherModel);
// Assert
Assert.AreEqual(otherName, model.Name);
Assert.AreSame(otherGeometry, model.Geometry);
PipingStochasticSoilProfile[] stochasticSoilProfiles = model.StochasticSoilProfiles.ToArray();
Assert.AreEqual(2, stochasticSoilProfiles.Length);
Assert.AreSame(stochasticProfileA, stochasticSoilProfiles[0]);
Assert.AreSame(otherStochasticProfileA.SoilProfile, stochasticSoilProfiles[0].SoilProfile);
Assert.AreNotSame(stochasticProfileB, stochasticSoilProfiles[1]);
Assert.AreSame(otherStochasticProfileB.SoilProfile, stochasticSoilProfiles[1].SoilProfile);
CollectionAssert.AreEqual(new[]
{
stochasticProfileA
}, difference.UpdatedProfiles);
CollectionAssert.AreEqual(new[]
{
stochasticProfileB
}, difference.RemovedProfiles);
CollectionAssert.AreEqual(new[]
{
otherStochasticProfileB
}, difference.AddedProfiles);
}
public void GenerateCalculationItemsStructure_SurfaceLineIntersectingSoilModelAndGenerateSemiProbabilisticAndProbabilisticFalse_ReturnEmptyCollection()
{
// Setup
var soilProfile1 = new PipingStochasticSoilProfile(
0.3, new PipingSoilProfile("Profile 1", -10.0, new[]
{
new PipingSoilLayer(-5.0),
new PipingSoilLayer(-2.0),
new PipingSoilLayer(1.0)
}, SoilProfileType.SoilProfile1D)
);
var soilProfile2 = new PipingStochasticSoilProfile(0.7, new PipingSoilProfile("Profile 2", -8.0, new[]
{
new PipingSoilLayer(-4.0),
new PipingSoilLayer(0.0),
new PipingSoilLayer(4.0)
}, SoilProfileType.SoilProfile1D)
);
var soilModel = new PipingStochasticSoilModel("A", new[]
{
new Point2D(1.0, 0.0),
new Point2D(5.0, 0.0)
}, new[]
{
soilProfile1,
soilProfile2
});
PipingStochasticSoilModel[] availableSoilModels =
{
soilModel
};
var surfaceLine = new PipingSurfaceLine("surface line");
surfaceLine.SetGeometry(new[]
{
new Point3D(3.0, 5.0, 0.0),
new Point3D(3.0, 0.0, 1.0),
new Point3D(3.0, -5.0, 0.0)
});
PipingSurfaceLine[] surfaceLines =
{
surfaceLine
};
// Call
IEnumerable <ICalculationBase> result = PipingCalculationConfigurationHelper.GenerateCalculationItemsStructure(
surfaceLines, false, false,
availableSoilModels).ToArray();
// Assert
CollectionAssert.IsEmpty(result);
}
public void Import_StochasticSoilProfileUnknown_LogMessageAndContinueImport()
{
// Setup
string filePath = TestHelper.GetScratchPadPath(nameof(Import_StochasticSoilProfileUnknown_LogMessageAndContinueImport));
SetCalculationType(Path.Combine(importerPath, "validConfigurationCalculationContainingUnknownSoilProfile.xml"), filePath);
var calculationGroup = new CalculationGroup();
var surfaceLine = new PipingSurfaceLine("Profielschematisatie");
surfaceLine.SetGeometry(new[]
{
new Point3D(3.0, 5.0, 0.0),
new Point3D(3.0, 0.0, 1.0),
new Point3D(3.0, -5.0, 0.0)
});
PipingStochasticSoilModel stochasticSoilModel = PipingStochasticSoilModelTestFactory.CreatePipingStochasticSoilModel(
"Ondergrondmodel",
new[]
{
new Point2D(1.0, 0.0),
new Point2D(5.0, 0.0)
});
var pipingFailureMechanism = new PipingFailureMechanism();
pipingFailureMechanism.SurfaceLines.AddRange(new[]
{
surfaceLine
}, "readerPath");
pipingFailureMechanism.StochasticSoilModels.AddRange(new[]
{
stochasticSoilModel
}, "readerPath");
var importer = new PipingCalculationConfigurationImporter(
filePath, calculationGroup, new HydraulicBoundaryLocation[0], pipingFailureMechanism);
try
{
// Call
var successful = false;
void Call() => successful = importer.Import();
// Assert
const string expectedMessage = "De ondergrondschematisatie 'Ondergrondschematisatie' bestaat niet binnen het stochastische ondergrondmodel 'Ondergrondmodel'. " +
"Berekening 'Calculation' is overgeslagen.";
TestHelper.AssertLogMessageIsGenerated(Call, expectedMessage, 2);
Assert.IsTrue(successful);
CollectionAssert.IsEmpty(calculationGroup.Children);
}
finally
{
File.Delete(filePath);
}
}
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 GetStochasticSoilModelsForSurfaceLine_SurfaceLineIntersectingSoilModel_ReturnSoilModel()
{
// Setup
var soilProfile1 = new PipingStochasticSoilProfile(
0.3, new PipingSoilProfile("Profile 1", -10.0, new[]
{
new PipingSoilLayer(-5.0),
new PipingSoilLayer(-2.0),
new PipingSoilLayer(1.0)
}, SoilProfileType.SoilProfile1D));
var soilProfile2 = new PipingStochasticSoilProfile(
0.7, new PipingSoilProfile("Profile 2", -8.0, new[]
{
new PipingSoilLayer(-4.0),
new PipingSoilLayer(0.0),
new PipingSoilLayer(4.0)
}, SoilProfileType.SoilProfile1D));
var soilModel = new PipingStochasticSoilModel("A", new[]
{
new Point2D(1.0, 0.0),
new Point2D(5.0, 0.0)
}, new[]
{
soilProfile1,
soilProfile2
});
PipingStochasticSoilModel[] availableSoilModels =
{
soilModel
};
var surfaceLine = new PipingSurfaceLine("surface line");
surfaceLine.SetGeometry(new[]
{
new Point3D(3.0, 5.0, 0.0),
new Point3D(3.0, 0.0, 1.0),
new Point3D(3.0, -5.0, 0.0)
});
// Call
IEnumerable <PipingStochasticSoilModel> result = PipingCalculationConfigurationHelper.GetStochasticSoilModelsForSurfaceLine(
surfaceLine,
availableSoilModels);
// Assert
PipingStochasticSoilModel[] expected =
{
soilModel
};
CollectionAssert.AreEquivalent(expected, result);
}
public void StochasticSoilModel_AlwaysOnChange_NotifyObserverAndCalculationPropertyChanged()
{
// Setup
PipingStochasticSoilModel newModel = PipingStochasticSoilModelTestFactory.CreatePipingStochasticSoilModel();
var newValue = new DataGridViewComboBoxItemWrapper <PipingStochasticSoilModel>(newModel);
var calculation = new TestPipingCalculationScenario();
// Call & Assert
SetPropertyAndVerifyNotificationsAndOutputForCalculation(row => row.StochasticSoilModel = newValue, calculation);
}
private static void AddEntitiesForStochasticSoilProfiles(PipingStochasticSoilModel model,
PersistenceRegistry registry,
StochasticSoilModelEntity entity)
{
var i = 0;
foreach (PipingStochasticSoilProfile stochasticSoilProfile in model.StochasticSoilProfiles)
{
entity.PipingStochasticSoilProfileEntities.Add(stochasticSoilProfile.Create(registry, i++));
}
}
public void Text_Always_ReturnsTextFromStochasticSoilModel()
{
// Setup
const string name = "test test 123";
PipingStochasticSoilModel model = PipingStochasticSoilModelTestFactory.CreatePipingStochasticSoilModel(name);
// Call
string text = info.Text(model);
// Assert
Assert.AreEqual(name, text);
}
public void CreateInstance_WithStochasticSoilModel_NewPropertiesWithInputAsData()
{
// Setup
PipingStochasticSoilModel stochasticSoilModel = PipingStochasticSoilModelTestFactory.CreatePipingStochasticSoilModel();
// Call
IObjectProperties objectProperties = info.CreateInstance(stochasticSoilModel);
// Assert
Assert.IsInstanceOf <PipingStochasticSoilModelProperties>(objectProperties);
Assert.AreSame(stochasticSoilModel, objectProperties.Data);
}
public void RemoveStochasticSoilModel_PipingFailureMechanismNull_ThrowsArgumentNullException()
{
// Setup
PipingStochasticSoilModel soilModel = PipingStochasticSoilModelTestFactory.CreatePipingStochasticSoilModel();
// Call
void Call() => PipingDataSynchronizationService.RemoveStochasticSoilModel(null, soilModel);
// Assert
var exception = Assert.Throws <ArgumentNullException>(Call);
Assert.AreEqual("failureMechanism", exception.ParamName);
}
public void Create_StringPropertiesDoNotShareReference()
{
// Setup
const string name = "testName";
PipingStochasticSoilModel stochasticSoilModel = PipingStochasticSoilModelTestFactory.CreatePipingStochasticSoilModel(name);
var registry = new PersistenceRegistry();
// Call
StochasticSoilModelEntity entity = stochasticSoilModel.Create(registry, 0);
// Assert
TestHelper.AssertAreEqualButNotSame(name, entity.Name);
}
