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