public void ParameteredConstructor_CalculationNull_ThrowsArgumentNullException()
{
// Setup
var mocks = new MockRepository();
var assessmentSection = mocks.Stub <IAssessmentSection>();
mocks.ReplayAll();
var calculationInput = new MacroStabilityInwardsInput(new MacroStabilityInwardsInput.ConstructionProperties());
var surfaceLines = new[]
{
new MacroStabilityInwardsSurfaceLine(string.Empty)
};
MacroStabilityInwardsStochasticSoilModel[] stochasticSoilModels =
{
MacroStabilityInwardsStochasticSoilModelTestFactory.CreateValidStochasticSoilModel()
};
var failureMechanism = new MacroStabilityInwardsFailureMechanism();
// Call
TestDelegate call = () => new MacroStabilityInwardsInputContext(calculationInput, null, surfaceLines, stochasticSoilModels, failureMechanism, assessmentSection);
// Assert
var exception = Assert.Throws <ArgumentNullException>(call);
Assert.AreEqual("calculation", exception.ParamName);
mocks.VerifyAll();
}
public void UpdateModelWithImportedData_UpdateCurrentModelWithImportedModelWithOtherProfiles_ProfilesAdded()
{
// Setup
const string modelsName = "same model";
MacroStabilityInwardsStochasticSoilModel existingModel = MacroStabilityInwardsStochasticSoilModelTestFactory.CreateValidStochasticSoilModel(modelsName);
var failureMechanism = new MacroStabilityInwardsFailureMechanism();
MacroStabilityInwardsStochasticSoilModelCollection targetCollection = failureMechanism.StochasticSoilModels;
targetCollection.AddRange(new[]
{
existingModel
}, sourceFilePath);
var strategy = new MacroStabilityInwardsStochasticSoilModelUpdateDataStrategy(failureMechanism);
MacroStabilityInwardsStochasticSoilModel 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(existingModel.StochasticSoilProfiles.Count(), 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 MacroStabilityInwardsStochasticSoilModelCollection();
stochasticSoilModelCollection.AddRange(new[]
{
MacroStabilityInwardsStochasticSoilModelTestFactory.CreateValidStochasticSoilModel()
}, expectedFilePath);
var failureMechanism = new MacroStabilityInwardsFailureMechanism();
var context = new MacroStabilityInwardsStochasticSoilModelCollectionContext(stochasticSoilModelCollection, failureMechanism, assessmentSection);
// Call
string currentPath = updateInfo.CurrentPath(context);
// Assert
Assert.AreEqual(expectedFilePath, currentPath);
mocks.VerifyAll();
}
public void Create_WithStochasticSoilModels_ReturnsFailureMechanismEntityWithStochasticSoilModelEntities()
{
// Setup
var failureMechanism = new MacroStabilityInwardsFailureMechanism();
MacroStabilityInwardsStochasticSoilModelCollection stochasticSoilModels = failureMechanism.StochasticSoilModels;
stochasticSoilModels.AddRange(new[]
{
MacroStabilityInwardsStochasticSoilModelTestFactory.CreateValidStochasticSoilModel("name"),
MacroStabilityInwardsStochasticSoilModelTestFactory.CreateValidStochasticSoilModel("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.MacroStabilityInwardsFailureMechanismMetaEntities
.Single()
.StochasticSoilModelCollectionSourcePath;
TestHelper.AssertAreEqualButNotSame(stochasticSoilModels.SourcePath, stochasticSoilModelCollectionSourcePath);
}
public void GivenFailureMechanismWithoutSurfaceLinesAndSoilModels_WhenAddSoilModelAndNotify_ThenButtonDisabled()
{
// Given
var mocks = new MockRepository();
var assessmentSection = mocks.Stub <IAssessmentSection>();
ConfigureHydraulicBoundaryDatabase(assessmentSection);
mocks.ReplayAll();
var failureMechanism = new MacroStabilityInwardsFailureMechanism();
ShowMacroStabilityInwardsCalculationsView(failureMechanism.CalculationsGroup, failureMechanism, assessmentSection);
// When
failureMechanism.StochasticSoilModels.AddRange(new[]
{
MacroStabilityInwardsStochasticSoilModelTestFactory.CreateValidStochasticSoilModel()
}, "path");
failureMechanism.NotifyObservers();
// Then
var button = (Button) new ControlTester("generateButton").TheObject;
Assert.IsFalse(button.Enabled);
mocks.VerifyAll();
}
public void CreateStochasticSoilModelFeatures_GivenStochasticSoilModels_ReturnsStochasticSoilModelFeaturesCollection()
{
// Setup
var pointsOne = new[]
{
new Point2D(1.2, 2.3),
new Point2D(2.7, 2.0)
};
var pointsTwo = new[]
{
new Point2D(3.2, 23.3),
new Point2D(7.7, 12.6)
};
MacroStabilityInwardsStochasticSoilModel[] stochasticSoilModels =
{
MacroStabilityInwardsStochasticSoilModelTestFactory.CreateValidStochasticSoilModel("StochasticSoilModelName1", pointsOne),
MacroStabilityInwardsStochasticSoilModelTestFactory.CreateValidStochasticSoilModel("StochasticSoilModelName2", pointsTwo)
};
// Call
IEnumerable <MapFeature> features = MacroStabilityInwardsMapDataFeaturesFactory.CreateStochasticSoilModelFeatures(stochasticSoilModels);
// Assert
Assert.AreEqual(stochasticSoilModels.Length, features.Count());
for (var i = 0; i < features.Count(); i++)
{
Assert.AreEqual(1, features.ElementAt(i).MapGeometries.Count());
AssertEqualPointCollections(stochasticSoilModels[i].Geometry, features.ElementAt(i).MapGeometries.First());
Assert.AreEqual(1, features.ElementAt(i).MetaData.Keys.Count);
Assert.AreEqual(stochasticSoilModels[i].Name, features.ElementAt(i).MetaData["Naam"]);
}
}
public void GivenViewWithStochasticSoilModels_WhenStochasticSoilModelsUpdatedAndNotified_ThenMapDataUpdated()
{
// Given
var failureMechanism = new MacroStabilityInwardsFailureMechanism();
MacroStabilityInwardsFailureMechanismView view = CreateView(failureMechanism, new AssessmentSectionStub());
IMapControl map = ((RiskeerMapControl)view.Controls[0]).MapControl;
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[]
{
MacroStabilityInwardsStochasticSoilModelTestFactory.CreateValidStochasticSoilModel("", new[]
{
new Point2D(1, 2),
new Point2D(1, 2)
})
}, "path");
failureMechanism.StochasticSoilModels.NotifyObservers();
// Then
AssertStochasticSoilModelsMapData(failureMechanism.StochasticSoilModels, stochasticSoilModelMapData);
mocks.VerifyAll();
}
public void Transform_ValidStochasticSoilModelWithSameProfileInTwoStochasticSoilProfiles_ReturnsExpectedMacroStabilityInwardsStochasticSoilModel(ISoilProfile soilProfile)
{
// Setup
const string soilModelName = "name";
const double originalProfileOneProbability = 0.2;
const double originalProfileTwoProbability = 0.7;
StochasticSoilModel soilModel =
MacroStabilityInwardsStochasticSoilModelTestFactory.CreateMacroStabilityInwardsStochasticSoilModelWithGeometry(soilModelName, new[]
{
new StochasticSoilProfile(originalProfileOneProbability, soilProfile),
new StochasticSoilProfile(originalProfileTwoProbability, soilProfile)
});
var transformer = new MacroStabilityInwardsStochasticSoilModelTransformer();
MacroStabilityInwardsStochasticSoilModel transformed = null;
// Call
Action call = () => transformed = transformer.Transform(soilModel);
// Assert
string expectedMessage = $"Ondergrondschematisatie '{soilProfile.Name}' is meerdere keren gevonden in ondergrondmodel '{soilModelName}'. " +
"Kansen van voorkomen worden opgeteld.";
TestHelper.AssertLogMessageWithLevelIsGenerated(call, Tuple.Create(expectedMessage, LogLevelConstant.Warn));
MacroStabilityInwardsStochasticSoilProfile[] transformedStochasticSoilProfiles = transformed.StochasticSoilProfiles.ToArray();
Assert.AreEqual(1, transformedStochasticSoilProfiles.Length);
const double expectedProbability = originalProfileOneProbability + originalProfileTwoProbability;
Assert.AreEqual(expectedProbability, transformedStochasticSoilProfiles[0].Probability, 1e-6);
}
public void UpdateModelWithImportedData_WithCurrentModelsAndImportedMultipleModelsWithSameName_ThrowsUpdateDataException()
{
// Setup
const string nonUniqueName = "non-unique name";
var targetCollection = new MacroStabilityInwardsStochasticSoilModelCollection();
targetCollection.AddRange(new[]
{
MacroStabilityInwardsStochasticSoilModelTestFactory.CreateValidStochasticSoilModel(nonUniqueName)
}, sourceFilePath);
var strategy = new MacroStabilityInwardsStochasticSoilModelUpdateDataStrategy(new MacroStabilityInwardsFailureMechanism());
MacroStabilityInwardsStochasticSoilModel[] importedStochasticSoilModels =
{
MacroStabilityInwardsStochasticSoilModelTestFactory.CreateValidStochasticSoilModel(nonUniqueName),
MacroStabilityInwardsStochasticSoilModelTestFactory.CreateValidStochasticSoilModel(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 Clone_AllPropertiesSet_ReturnNewInstanceWithCopiedValues()
{
// Setup
var surfaceLine = new MacroStabilityInwardsSurfaceLine("Surface line");
surfaceLine.SetGeometry(new[]
{
new Point3D(0, 0, 0),
new Point3D(1, 1, 1)
});
MacroStabilityInwardsStochasticSoilModel stochasticSoilModel = MacroStabilityInwardsStochasticSoilModelTestFactory.CreateValidStochasticSoilModel();
MacroStabilityInwardsStochasticSoilProfile stochasticSoilProfile = stochasticSoilModel.StochasticSoilProfiles.First();
// Precondition
Assert.IsNotNull(stochasticSoilProfile);
var original = new MacroStabilityInwardsInput(new MacroStabilityInwardsInput.ConstructionProperties());
MacroStabilityInwardsTestDataGenerator.SetRandomMacroStabilityInwardsInput(original);
// Call
object clone = original.Clone();
// Assert
CoreCloneAssert.AreObjectClones(original, clone, MacroStabilityInwardsCloneAssert.AreClones);
}
public void ParameteredConstructor_ExpectedValues()
{
// Setup
var mocks = new MockRepository();
var assessmentSection = mocks.Stub <IAssessmentSection>();
mocks.ReplayAll();
var calculation = new MacroStabilityInwardsCalculationScenario();
var surfaceLines = new[]
{
new MacroStabilityInwardsSurfaceLine(string.Empty)
};
MacroStabilityInwardsStochasticSoilModel[] stochasticSoilModels =
{
MacroStabilityInwardsStochasticSoilModelTestFactory.CreateValidStochasticSoilModel()
};
var failureMechanism = new MacroStabilityInwardsFailureMechanism();
// Call
var context = new MacroStabilityInwardsInputContext(calculation.InputParameters, calculation, surfaceLines, stochasticSoilModels, failureMechanism, assessmentSection);
// Assert
Assert.IsInstanceOf <MacroStabilityInwardsContext <MacroStabilityInwardsInput> >(context);
Assert.AreSame(calculation.InputParameters, context.WrappedData);
Assert.AreSame(calculation, context.MacroStabilityInwardsCalculation);
Assert.AreSame(failureMechanism, context.FailureMechanism);
Assert.AreSame(assessmentSection, context.AssessmentSection);
CollectionAssert.AreEqual(surfaceLines, context.AvailableMacroStabilityInwardsSurfaceLines);
CollectionAssert.AreEqual(stochasticSoilModels, context.AvailableStochasticSoilModels);
mocks.VerifyAll();
}
public void IntersectsWithSurfaceLineGeometry_SurfaceLineIntersectingSoilModel_ReturnTrue()
{
// Setup
MacroStabilityInwardsStochasticSoilModel soilModel =
MacroStabilityInwardsStochasticSoilModelTestFactory.CreateValidStochasticSoilModel("A", new[]
{
new Point2D(1.0, 0.0),
new Point2D(5.0, 0.0)
});
var surfaceLine = new MacroStabilityInwardsSurfaceLine(string.Empty);
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
bool intersecting = soilModel.IntersectsWithSurfaceLineGeometry(surfaceLine);
// Assert
Assert.IsTrue(intersecting);
}
public void ButtonGenerateScenarios_WithSurfaceLinesAndSoilModels_ButtonEnabled()
{
// Setup
var mocks = new MockRepository();
var assessmentSection = mocks.Stub <IAssessmentSection>();
ConfigureHydraulicBoundaryDatabase(assessmentSection);
mocks.ReplayAll();
const string arbitrarySourcePath = "path";
var failureMechanism = new MacroStabilityInwardsFailureMechanism();
failureMechanism.SurfaceLines.AddRange(new[]
{
new MacroStabilityInwardsSurfaceLine(string.Empty)
}, arbitrarySourcePath);
failureMechanism.StochasticSoilModels.AddRange(new[]
{
MacroStabilityInwardsStochasticSoilModelTestFactory.CreateValidStochasticSoilModel()
}, arbitrarySourcePath);
ShowMacroStabilityInwardsCalculationsView(new CalculationGroup(), failureMechanism, assessmentSection);
var button = (Button) new ControlTester("generateButton").TheObject;
// Call
bool state = button.Enabled;
// Assert
Assert.IsTrue(state);
mocks.VerifyAll();
}
public void ChildNodeObjects_Always_ReturnsChildrenOfData()
{
// Setup
var stochasticSoilProfile1 = new MacroStabilityInwardsStochasticSoilProfile(
1.0,
new MacroStabilityInwardsSoilProfile1D("soilProfile1", 0, new List <MacroStabilityInwardsSoilLayer1D>
{
new MacroStabilityInwardsSoilLayer1D(10)
}));
var stochasticSoilProfile2 = new MacroStabilityInwardsStochasticSoilProfile(
1.0,
new MacroStabilityInwardsSoilProfile1D("soilProfile2", 0, new List <MacroStabilityInwardsSoilLayer1D>
{
new MacroStabilityInwardsSoilLayer1D(10)
}));
MacroStabilityInwardsStochasticSoilModel stochasticSoilModel =
MacroStabilityInwardsStochasticSoilModelTestFactory.CreateValidStochasticSoilModel("SoilModel", new[]
{
stochasticSoilProfile1,
stochasticSoilProfile2
});
// Call
object[] objects = info.ChildNodeObjects(stochasticSoilModel);
// Assert
MacroStabilityInwardsStochasticSoilProfile[] expectedChildren =
{
stochasticSoilProfile1,
stochasticSoilProfile2
};
CollectionAssert.AreEqual(expectedChildren, objects);
}
public void ForeColor_CollectionWithSoilProfiles_ReturnsControlText()
{
// Setup
var assessmentSection = mocks.Stub <IAssessmentSection>();
mocks.ReplayAll();
var failureMechanism = new MacroStabilityInwardsFailureMechanism();
failureMechanism.StochasticSoilModels.AddRange(new[]
{
MacroStabilityInwardsStochasticSoilModelTestFactory.CreateValidStochasticSoilModel()
}, "path");
var stochasticSoilModelCollectionContext = new MacroStabilityInwardsStochasticSoilModelCollectionContext(
failureMechanism.StochasticSoilModels,
failureMechanism,
assessmentSection);
// Call
Color foreColor = info.ForeColor(stochasticSoilModelCollectionContext);
// Assert
Assert.AreEqual(Color.FromKnownColor(KnownColor.ControlText), foreColor);
}
public void ContextMenuStrip_Always_CallsBuilder()
{
// Setup
MacroStabilityInwardsStochasticSoilModel model = MacroStabilityInwardsStochasticSoilModelTestFactory.CreateValidStochasticSoilModel();
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 SetMatchingStochasticSoilModel_CurrentSoilModelNotInOverlappingMultipleSoilModels_ClearsModel()
{
// Setup
MacroStabilityInwardsStochasticSoilModel nonOverlappingSoilModel =
MacroStabilityInwardsStochasticSoilModelTestFactory.CreateValidStochasticSoilModel("A");
var input = new MacroStabilityInwardsInput(new MacroStabilityInwardsInput.ConstructionProperties())
{
StochasticSoilModel = nonOverlappingSoilModel
};
MacroStabilityInwardsStochasticSoilModel soilModel1 =
MacroStabilityInwardsStochasticSoilModelTestFactory.CreateValidStochasticSoilModel("A");
MacroStabilityInwardsStochasticSoilModel soilModel2 =
MacroStabilityInwardsStochasticSoilModelTestFactory.CreateValidStochasticSoilModel("C");
// Call
MacroStabilityInwardsInputService.SetMatchingStochasticSoilModel(input, new[]
{
soilModel1,
soilModel2
});
// Assert
Assert.IsNull(input.StochasticSoilModel);
}
public void Read_EntityWithStochasticSoilModel_ReturnCalculationScenarioWithInputObjectWithStochasticSoilModelPropertiesSet()
{
// Setup
var random = new Random(21);
MacroStabilityInwardsStochasticSoilModel stochasticSoilModel =
MacroStabilityInwardsStochasticSoilModelTestFactory.CreateValidStochasticSoilModel();
var stochasticSoilModelEntity = new StochasticSoilModelEntity();
var stochasticSoilProfile = new MacroStabilityInwardsStochasticSoilProfile(random.NextDouble(),
MacroStabilityInwardsSoilProfile1DTestFactory.CreateMacroStabilityInwardsSoilProfile1D());
var stochasticSoilProfileEntity = new MacroStabilityInwardsStochasticSoilProfileEntity
{
StochasticSoilModelEntity = stochasticSoilModelEntity
};
var collector = new ReadConversionCollector();
collector.Read(stochasticSoilModelEntity, stochasticSoilModel);
collector.Read(stochasticSoilProfileEntity, stochasticSoilProfile);
MacroStabilityInwardsCalculationEntity entity = CreateValidCalculationEntity();
entity.MacroStabilityInwardsStochasticSoilProfileEntity = stochasticSoilProfileEntity;
// Call
MacroStabilityInwardsCalculationScenario calculation = entity.Read(collector);
// Assert
MacroStabilityInwardsInput inputParameters = calculation.InputParameters;
Assert.AreSame(stochasticSoilModel, inputParameters.StochasticSoilModel);
Assert.AreSame(stochasticSoilProfile, inputParameters.StochasticSoilProfile);
}
public void Create_WithStochasticSoilProfiles_ReturnsStochasticSoilModelEntityWithPropertiesSet()
{
// Setup
var stochasticSoilProfiles = new[]
{
new MacroStabilityInwardsStochasticSoilProfile(0.1, MacroStabilityInwardsSoilProfile1DTestFactory.CreateMacroStabilityInwardsSoilProfile1D()),
new MacroStabilityInwardsStochasticSoilProfile(0.9, MacroStabilityInwardsSoilProfile2DTestFactory.CreateMacroStabilityInwardsSoilProfile2D())
};
MacroStabilityInwardsStochasticSoilModel stochasticSoilModel =
MacroStabilityInwardsStochasticSoilModelTestFactory.CreateValidStochasticSoilModel("Model", stochasticSoilProfiles);
var registry = new PersistenceRegistry();
// Call
StochasticSoilModelEntity entity = stochasticSoilModel.Create(registry, 0);
// Assert
Assert.IsNotNull(entity);
CollectionAssert.IsEmpty(entity.PipingStochasticSoilProfileEntities);
Assert.AreEqual(stochasticSoilProfiles.Length, entity.MacroStabilityInwardsStochasticSoilProfileEntities.Count);
MacroStabilityInwardsStochasticSoilProfile firstStochasticSoilProfile = stochasticSoilProfiles[0];
MacroStabilityInwardsStochasticSoilProfileEntity firstStochasticSoilProfileEntity = entity.MacroStabilityInwardsStochasticSoilProfileEntities.First();
Assert.AreEqual(firstStochasticSoilProfile.Probability, firstStochasticSoilProfileEntity.Probability);
Assert.IsNotNull(firstStochasticSoilProfileEntity.MacroStabilityInwardsSoilProfileOneDEntity);
Assert.IsNull(firstStochasticSoilProfileEntity.MacroStabilityInwardsSoilProfileTwoDEntity);
MacroStabilityInwardsStochasticSoilProfile secondStochasticSoilProfile = stochasticSoilProfiles[1];
MacroStabilityInwardsStochasticSoilProfileEntity secondStochasticSoilProfileEntity = entity.MacroStabilityInwardsStochasticSoilProfileEntities.ElementAt(1);
Assert.AreEqual(secondStochasticSoilProfile.Probability, secondStochasticSoilProfileEntity.Probability);
Assert.IsNull(secondStochasticSoilProfileEntity.MacroStabilityInwardsSoilProfileOneDEntity);
Assert.IsNotNull(secondStochasticSoilProfileEntity.MacroStabilityInwardsSoilProfileTwoDEntity);
}
public void UpdateModelWithImportedData_WithCurrentModelAndImportedModelWithOtherName_ModelReplaced()
{
// Setup
MacroStabilityInwardsStochasticSoilModel existingModel = MacroStabilityInwardsStochasticSoilModelTestFactory.CreateValidStochasticSoilModel("existing");
var failureMechanism = new MacroStabilityInwardsFailureMechanism();
failureMechanism.StochasticSoilModels.AddRange(new[]
{
existingModel
}, sourceFilePath);
var strategy = new MacroStabilityInwardsStochasticSoilModelUpdateDataStrategy(failureMechanism);
MacroStabilityInwardsStochasticSoilModel readModel = MacroStabilityInwardsStochasticSoilModelTestFactory.CreateValidStochasticSoilModel("read");
// Call
IEnumerable <IObservable> affectedObjects = strategy.UpdateModelWithImportedData(new[]
{
readModel
}, sourceFilePath);
// Assert
Assert.AreSame(readModel, failureMechanism.StochasticSoilModels[0]);
CollectionAssert.AreEqual(new[]
{
failureMechanism.StochasticSoilModels
}, affectedObjects);
}
private static MacroStabilityInwardsFailureMechanism ConfigureSimpleFailureMechanism()
{
var surfaceLine1 = new MacroStabilityInwardsSurfaceLine("Surface line 1")
{
ReferenceLineIntersectionWorldPoint = new Point2D(0.0, 0.0)
};
surfaceLine1.SetGeometry(new[]
{
new Point3D(0.0, 5.0, 0.0),
new Point3D(0.0, 0.0, 1.0),
new Point3D(0.0, -5.0, 0.0)
});
var surfaceLine2 = new MacroStabilityInwardsSurfaceLine("Surface line 2")
{
ReferenceLineIntersectionWorldPoint = new Point2D(5.0, 0.0)
};
surfaceLine2.SetGeometry(new[]
{
new Point3D(5.0, 5.0, 0.0),
new Point3D(5.0, 0.0, 1.0),
new Point3D(5.0, -5.0, 0.0)
});
var failureMechanism = new MacroStabilityInwardsFailureMechanism();
const string sourcePath = "path";
failureMechanism.SurfaceLines.AddRange(new[]
{
surfaceLine1,
surfaceLine2
}, sourcePath);
failureMechanism.StochasticSoilModels.AddRange(new[]
{
MacroStabilityInwardsStochasticSoilModelTestFactory.CreateValidStochasticSoilModel("name", new[]
{
new Point2D(0.0, 0.0),
new Point2D(5.0, 0.0)
})
}, sourcePath);
FailureMechanismTestHelper.SetSections(failureMechanism, new[]
{
new FailureMechanismSection("Section 1", new[]
{
new Point2D(0.0, 0.0),
new Point2D(5.0, 0.0)
}),
new FailureMechanismSection("Section 2", new[]
{
new Point2D(5.0, 0.0),
new Point2D(10.0, 0.0)
})
});
return(failureMechanism);
}
protected override IEnumerable <MacroStabilityInwardsStochasticSoilModel> SingleNonUniqueElements()
{
const string someName = "Soil model";
yield return(MacroStabilityInwardsStochasticSoilModelTestFactory.CreateValidStochasticSoilModel(someName));
yield return(MacroStabilityInwardsStochasticSoilModelTestFactory.CreateValidStochasticSoilModel(someName));
}
public void StochasticSoilModel_AlwaysOnChange_NotifyObserverCalculationPropertyChangedOutputCleared()
{
// Setup
MacroStabilityInwardsStochasticSoilModel newModel = MacroStabilityInwardsStochasticSoilModelTestFactory.CreateValidStochasticSoilModel();
var newValue = new DataGridViewComboBoxItemWrapper <MacroStabilityInwardsStochasticSoilModel>(newModel);
var calculation = new MacroStabilityInwardsCalculationScenario();
// Call & Assert
SetPropertyAndVerifyNotificationsAndOutputForCalculation(row => row.StochasticSoilModel = newValue, calculation);
}
public void GivenCalculationsView_WhenStochasticSoilModelsUpdatedAndNotified_ThenStochasticSoilModelsAndStochasticSoilProfilesComboboxCorrectlyUpdated()
{
// Given
var mocks = new MockRepository();
var assessmentSection = mocks.Stub <IAssessmentSection>();
ConfigureHydraulicBoundaryDatabase(assessmentSection);
mocks.ReplayAll();
MacroStabilityInwardsFailureMechanism failureMechanism = ConfigureFailureMechanism();
ShowMacroStabilityInwardsCalculationsView(ConfigureCalculationGroup(assessmentSection, failureMechanism), failureMechanism, assessmentSection);
var dataGridView = (DataGridView) new ControlTester("dataGridView").TheObject;
var soilModelsComboBox = (DataGridViewComboBoxColumn)dataGridView.Columns[stochasticSoilModelsColumnIndex];
var soilProfilesComboBox = (DataGridViewComboBoxColumn)dataGridView.Columns[stochasticSoilProfilesColumnIndex];
// Precondition
Assert.AreEqual(4, soilModelsComboBox.Items.Count);
Assert.AreEqual(6, soilProfilesComboBox.Items.Count);
// When
failureMechanism.StochasticSoilModels.AddRange(new[]
{
MacroStabilityInwardsStochasticSoilModelTestFactory.CreateValidStochasticSoilModel("Model F", new[]
{
new Point2D(0.0, 0.0),
new Point2D(5.0, 0.0)
})
}, string.Empty);
failureMechanism.StochasticSoilModels.NotifyObservers();
// Then
DataGridViewComboBoxCell.ObjectCollection soilModelItems = soilModelsComboBox.Items;
DataGridViewComboBoxCell.ObjectCollection soilProfileItems = soilProfilesComboBox.Items;
Assert.AreEqual(5, soilModelItems.Count);
Assert.AreEqual("<selecteer>", soilModelItems[0].ToString());
Assert.AreEqual("Model A", soilModelItems[1].ToString());
Assert.AreEqual("Model C", soilModelItems[2].ToString());
Assert.AreEqual("Model E", soilModelItems[3].ToString());
Assert.AreEqual("Model F", soilModelItems[4].ToString());
Assert.AreEqual(8, soilProfileItems.Count);
Assert.AreEqual("<selecteer>", soilProfileItems[0].ToString());
Assert.AreEqual("Profile 1", soilProfileItems[1].ToString());
Assert.AreEqual("Profile 2", soilProfileItems[2].ToString());
Assert.AreEqual("Profile 3", soilProfileItems[3].ToString());
Assert.AreEqual("Profile 4", soilProfileItems[4].ToString());
Assert.AreEqual("Profile 5", soilProfileItems[5].ToString());
Assert.AreEqual("A", soilProfileItems[6].ToString());
mocks.VerifyAll();
}
/// <summary>
/// Creates a simple model with names for the model and profiles in the model set as specified.
/// </summary>
/// <param name="modelName">Name of the created model.</param>
/// <param name="profileNames">List of names for the profiles to be added to the model.</param>
/// <returns>A new <see cref="MacroStabilityInwardsStochasticSoilModel"/>.</returns>
private static MacroStabilityInwardsStochasticSoilModel CreateSimpleModel(string modelName, params string[] profileNames)
{
var stochasticSoilProfiles = new List <MacroStabilityInwardsStochasticSoilProfile>();
foreach (string profileName in profileNames)
{
MacroStabilityInwardsSoilProfile1D soilProfile = MacroStabilityInwardsSoilProfile1DTestFactory.CreateMacroStabilityInwardsSoilProfile1D(profileName);
stochasticSoilProfiles.Add(new MacroStabilityInwardsStochasticSoilProfile(1.0 / profileNames.Length, soilProfile));
}
return(MacroStabilityInwardsStochasticSoilModelTestFactory.CreateValidStochasticSoilModel(modelName, stochasticSoilProfiles));
}
public void Transform_ValidStochasticSoilModelWithSoilProfile2D_ReturnsExpectedMacroStabilityInwardsStochasticSoilModel()
{
// Setup
var random = new Random(21);
double probability = random.NextDouble();
var transformer = new MacroStabilityInwardsStochasticSoilModelTransformer();
StochasticSoilModel soilModel =
MacroStabilityInwardsStochasticSoilModelTestFactory.CreateMacroStabilityInwardsStochasticSoilModelWithGeometry("some name", new[]
{
new StochasticSoilProfile(probability, new SoilProfile2D(2, "test", new[]
{
SoilLayer2DTestFactory.CreateSoilLayer2D()
}, Enumerable.Empty <PreconsolidationStress>()))
});
// Call
MacroStabilityInwardsStochasticSoilModel transformedModel = transformer.Transform(soilModel);
// Assert
Assert.AreEqual(soilModel.Name, transformedModel.Name);
CollectionAssert.AreEqual(soilModel.Geometry, transformedModel.Geometry);
Assert.AreEqual(1, transformedModel.StochasticSoilProfiles.Count());
var expectedStochasticSoilProfile = new MacroStabilityInwardsStochasticSoilProfile(probability, new MacroStabilityInwardsSoilProfile2D("test", new[]
{
new MacroStabilityInwardsSoilLayer2D(new Ring(new[]
{
new Point2D(1.0, 1.0),
new Point2D(2.0, 1.0)
}),
new MacroStabilityInwardsSoilLayerData
{
UsePop = true
},
new[]
{
new MacroStabilityInwardsSoilLayer2D(new Ring(new[]
{
new Point2D(0.0, 0.0),
new Point2D(1.0, 0.0)
}),
new MacroStabilityInwardsSoilLayerData
{
UsePop = true
},
Enumerable.Empty <MacroStabilityInwardsSoilLayer2D>())
})
}, Enumerable.Empty <MacroStabilityInwardsPreconsolidationStress>()));
AssertStochasticSoilProfile(expectedStochasticSoilProfile, transformedModel.StochasticSoilProfiles.First());
}
public void Text_Always_ReturnsTextFromStochasticSoilModel()
{
// Setup
const string name = "test test 123";
MacroStabilityInwardsStochasticSoilModel model =
MacroStabilityInwardsStochasticSoilModelTestFactory.CreateValidStochasticSoilModel(name);
// Call
string text = info.Text(model);
// Assert
Assert.AreEqual(name, text);
}
public void CreateInstance_WithContext_NewPropertiesWithInputContextAsData()
{
// Setup
MacroStabilityInwardsStochasticSoilModel context =
MacroStabilityInwardsStochasticSoilModelTestFactory.CreateValidStochasticSoilModel();
// Call
IObjectProperties objectProperties = info.CreateInstance(context);
// Assert
Assert.IsInstanceOf <MacroStabilityInwardsStochasticSoilModelProperties>(objectProperties);
Assert.AreSame(context, objectProperties.Data);
}
public void RemoveStochasticSoilModel_FailureMechanismNull_ThrowsArgumentNullException()
{
// Setup
MacroStabilityInwardsStochasticSoilModel soilModel = MacroStabilityInwardsStochasticSoilModelTestFactory.CreateValidStochasticSoilModel();
// Call
void Call() => MacroStabilityInwardsDataSynchronizationService.RemoveStochasticSoilModel(null, soilModel);
// Assert
var exception = Assert.Throws <ArgumentNullException>(Call);
Assert.AreEqual("failureMechanism", exception.ParamName);
}
public void Create_PersistenceRegistryNull_ThrowsArgumentNullException()
{
// Setup
MacroStabilityInwardsStochasticSoilModel stochasticSoilModel =
MacroStabilityInwardsStochasticSoilModelTestFactory.CreateValidStochasticSoilModel();
// Call
TestDelegate test = () => stochasticSoilModel.Create(null, 0);
// Assert
string parameterName = Assert.Throws <ArgumentNullException>(test).ParamName;
Assert.AreEqual("registry", parameterName);
}
