public void CurrentPath_StochasticSoilModelCollectionHasPathSet_ReturnsExpectedPath() { // Setup var mocks = new MockRepository(); var assessmentSection = mocks.Stub <IAssessmentSection>(); mocks.ReplayAll(); const string expectedFilePath = "some/path"; var stochasticSoilModelCollection = new PipingStochasticSoilModelCollection(); stochasticSoilModelCollection.AddRange(new[] { PipingStochasticSoilModelTestFactory.CreatePipingStochasticSoilModel() }, expectedFilePath); var failureMechanism = new PipingFailureMechanism(); var context = new PipingStochasticSoilModelCollectionContext(stochasticSoilModelCollection, failureMechanism, assessmentSection); // Call string currentPath = updateInfo.CurrentPath(context); // Assert Assert.AreEqual(expectedFilePath, currentPath); mocks.VerifyAll(); }
public void 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 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 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 ParameteredConstructor_ParentNull_ThrowsArgumentNullException() { // Setup var mocks = new MockRepository(); var assessmentSection = mocks.Stub <IAssessmentSection>(); mocks.ReplayAll(); var surfaceLines = new[] { new PipingSurfaceLine(string.Empty) }; PipingStochasticSoilModel[] soilModels = { PipingStochasticSoilModelTestFactory.CreatePipingStochasticSoilModel() }; var calculation = new SemiProbabilisticPipingCalculationScenario(); var failureMechanism = new PipingFailureMechanism(); // Call TestDelegate call = () => new SemiProbabilisticPipingCalculationScenarioContext(calculation, null, surfaceLines, soilModels, failureMechanism, assessmentSection); // Assert var exception = Assert.Throws <ArgumentNullException>(call); Assert.AreEqual("parent", exception.ParamName); mocks.VerifyAll(); }
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(); }
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) }; PipingStochasticSoilModel[] stochasticSoilModels = { PipingStochasticSoilModelTestFactory.CreatePipingStochasticSoilModel("StochasticSoilModelName1", pointsOne), PipingStochasticSoilModelTestFactory.CreatePipingStochasticSoilModel("StochasticSoilModelName2", pointsTwo) }; // Call IEnumerable <MapFeature> features = PipingMapDataFeaturesFactory.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 ParameteredConstructor_ExpectedValues() { // Setup var mocks = new MockRepository(); var assessmentSection = mocks.Stub <IAssessmentSection>(); mocks.ReplayAll(); var calculation = new ProbabilisticPipingCalculationScenario(); var surfaceLines = new[] { new PipingSurfaceLine(string.Empty) }; PipingStochasticSoilModel[] stochasticSoilModels = { PipingStochasticSoilModelTestFactory.CreatePipingStochasticSoilModel() }; var failureMechanism = new PipingFailureMechanism(); // Call var context = new ProbabilisticPipingInputContext(calculation.InputParameters, calculation, surfaceLines, stochasticSoilModels, failureMechanism, assessmentSection); // Assert Assert.IsInstanceOf <PipingContext <ProbabilisticPipingInput> >(context); Assert.AreSame(calculation.InputParameters, context.WrappedData); Assert.AreSame(calculation, context.PipingCalculation); Assert.AreSame(failureMechanism, context.FailureMechanism); Assert.AreSame(assessmentSection, context.AssessmentSection); CollectionAssert.AreEqual(surfaceLines, context.AvailablePipingSurfaceLines); CollectionAssert.AreEqual(stochasticSoilModels, context.AvailableStochasticSoilModels); mocks.VerifyAll(); }
public void ForeColor_CollectionWithSoilModels_ReturnsControlText() { // Setup var assessmentSection = mocks.Stub <IAssessmentSection>(); mocks.ReplayAll(); var failureMechanism = new PipingFailureMechanism(); failureMechanism.StochasticSoilModels.AddRange(new[] { PipingStochasticSoilModelTestFactory.CreatePipingStochasticSoilModel() }, "path"); var stochasticSoilModelCollectionContext = new PipingStochasticSoilModelCollectionContext( failureMechanism.StochasticSoilModels, failureMechanism, assessmentSection); // Call Color foreColor = info.ForeColor(stochasticSoilModelCollectionContext); // Assert Assert.AreEqual(Color.FromKnownColor(KnownColor.ControlText), foreColor); }
public void Create_WithStochasticSoilModels_ReturnsFailureMechanismEntityWithStochasticSoilModelEntities() { // Setup var failureMechanism = new PipingFailureMechanism(); PipingStochasticSoilModelCollection stochasticSoilModels = failureMechanism.StochasticSoilModels; stochasticSoilModels.AddRange(new[] { PipingStochasticSoilModelTestFactory.CreatePipingStochasticSoilModel("name"), PipingStochasticSoilModelTestFactory.CreatePipingStochasticSoilModel("name2") }, "some/path/to/file"); var registry = new PersistenceRegistry(); // Call FailureMechanismEntity entity = failureMechanism.Create(registry); // Assert Assert.IsNotNull(entity); Assert.AreEqual(stochasticSoilModels.Count, entity.StochasticSoilModelEntities.Count); for (var i = 0; i < stochasticSoilModels.Count; i++) { AssertStochasticSoilModel(stochasticSoilModels[i], entity.StochasticSoilModelEntities.ElementAt(i)); } string stochasticSoilModelCollectionSourcePath = entity.PipingFailureMechanismMetaEntities .Single() .StochasticSoilModelCollectionSourcePath; TestHelper.AssertAreEqualButNotSame(stochasticSoilModels.SourcePath, stochasticSoilModelCollectionSourcePath); }
public void UpdateModelWithImportedData_WithCurrentModelsAndImportedMultipleModelsWithSameName_ThrowsUpdateDataException() { // Setup const string nonUniqueName = "non-unique name"; var targetCollection = new PipingStochasticSoilModelCollection(); targetCollection.AddRange(new[] { PipingStochasticSoilModelTestFactory.CreatePipingStochasticSoilModel(nonUniqueName) }, sourceFilePath); var strategy = new PipingStochasticSoilModelUpdateDataStrategy(new PipingFailureMechanism()); PipingStochasticSoilModel[] importedStochasticSoilModels = { PipingStochasticSoilModelTestFactory.CreatePipingStochasticSoilModel(nonUniqueName), PipingStochasticSoilModelTestFactory.CreatePipingStochasticSoilModel(nonUniqueName) }; // Call TestDelegate test = () => strategy.UpdateModelWithImportedData(importedStochasticSoilModels, sourceFilePath); // Assert var exception = Assert.Throws <UpdateDataException>(test); const string expectedMessage = "Geïmporteerde data moet unieke elementen bevatten."; Assert.AreEqual(expectedMessage, exception.Message); }
public void 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); }
public void UpdateModelWithImportedData_UpdateCurrentModelWithImportedModelWithOtherProfiles_ProfilesAdded() { // Setup const string modelsName = "same model"; PipingStochasticSoilModel existingModel = PipingStochasticSoilModelTestFactory.CreatePipingStochasticSoilModel(modelsName); var failureMechanism = new PipingFailureMechanism(); PipingStochasticSoilModelCollection targetCollection = failureMechanism.StochasticSoilModels; targetCollection.AddRange(new[] { existingModel }, sourceFilePath); var strategy = new PipingStochasticSoilModelUpdateDataStrategy(failureMechanism); PipingStochasticSoilModel readModel = CreateSimpleModel(modelsName, "new profile A", "new profile B"); // Call IEnumerable <IObservable> affectedObjects = strategy.UpdateModelWithImportedData(new[] { readModel }, sourceFilePath); // Assert Assert.AreEqual(1, targetCollection.Count); Assert.AreSame(existingModel, targetCollection[0]); Assert.AreEqual(2, targetCollection[0].StochasticSoilProfiles.Count()); CollectionAssert.AreEquivalent(new IObservable[] { targetCollection, existingModel }, affectedObjects); }
public void 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 EditValue_WithCurrentItemNotInAvailableItems_ReturnsOriginalValue() { // Setup var mockRepository = new MockRepository(); var provider = mockRepository.DynamicMock <IServiceProvider>(); var service = mockRepository.DynamicMock <IWindowsFormsEditorService>(); var context = mockRepository.DynamicMock <ITypeDescriptorContext>(); var hasStochasticSoilModel = mockRepository.Stub <IHasStochasticSoilModel>(); hasStochasticSoilModel.Stub(hssm => hssm.StochasticSoilModel).Return( PipingStochasticSoilModelTestFactory.CreatePipingStochasticSoilModel("StochasticSoilModelName")); hasStochasticSoilModel.Stub(hssm => hssm.GetAvailableStochasticSoilModels()).Return( new[] { PipingStochasticSoilModelTestFactory.CreatePipingStochasticSoilModel("NewStochasticSoilModelName") }); var editor = new PipingInputContextStochasticSoilModelSelectionEditor <IHasStochasticSoilModel>(); var someValue = new object(); var propertyBag = new DynamicPropertyBag(hasStochasticSoilModel); provider.Expect(p => p.GetService(null)).IgnoreArguments().Return(service); service.Expect(s => s.DropDownControl(null)).IgnoreArguments(); context.Expect(c => c.Instance).Return(propertyBag); mockRepository.ReplayAll(); // Call object result = editor.EditValue(context, provider, someValue); // Assert Assert.AreSame(someValue, result); mockRepository.VerifyAll(); }
protected override IEnumerable <PipingStochasticSoilModel> SingleNonUniqueElements() { const string someName = "Soil model"; yield return(PipingStochasticSoilModelTestFactory.CreatePipingStochasticSoilModel(someName)); yield return(PipingStochasticSoilModelTestFactory.CreatePipingStochasticSoilModel(someName)); }
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 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); }
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 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 Create_PersistenceRegistryNull_ThrowsArgumentNullException() { // Setup PipingStochasticSoilModel stochasticSoilModel = PipingStochasticSoilModelTestFactory.CreatePipingStochasticSoilModel(); // Call TestDelegate test = () => stochasticSoilModel.Create(null, 0); // Assert string parameterName = Assert.Throws <ArgumentNullException>(test).ParamName; Assert.AreEqual("registry", parameterName); }
/// <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="PipingStochasticSoilModel"/>.</returns> private static PipingStochasticSoilModel CreateSimpleModel(string modelName, params string[] profileNames) { var stochasticProfiles = new List <PipingStochasticSoilProfile>(); foreach (string profileName in profileNames) { stochasticProfiles.Add(new PipingStochasticSoilProfile( 1.0 / profileNames.Length, PipingSoilProfileTestFactory.CreatePipingSoilProfile(profileName))); } return(PipingStochasticSoilModelTestFactory.CreatePipingStochasticSoilModel(modelName, stochasticProfiles)); }
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); }
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_SameModelCreatedMultipleTimes_ReturnSameEntity() { // Setup PipingStochasticSoilModel soilModel = PipingStochasticSoilModelTestFactory.CreatePipingStochasticSoilModel("A"); var registry = new PersistenceRegistry(); // Call StochasticSoilModelEntity entity1 = soilModel.Create(registry, 0); StochasticSoilModelEntity entity2 = soilModel.Create(registry, 0); // Assert Assert.AreSame(entity1, entity2); }
public void Constructor_ValidStochasticSoilModel_ExpectedValues() { // Setup PipingStochasticSoilModel stochasticSoilModel = PipingStochasticSoilModelTestFactory.CreatePipingStochasticSoilModel(); // Call var properties = new PipingStochasticSoilModelProperties(stochasticSoilModel); // Assert Assert.IsInstanceOf <ObjectProperties <PipingStochasticSoilModel> >(properties); TestHelper.AssertTypeConverter <PipingStochasticSoilModelProperties, ExpandableArrayConverter>(nameof(PipingStochasticSoilModelProperties.Geometry)); TestHelper.AssertTypeConverter <PipingStochasticSoilModelProperties, ExpandableArrayConverter>(nameof(PipingStochasticSoilModelProperties.StochasticSoilProfiles)); Assert.AreSame(stochasticSoilModel, properties.Data); }
public void SetMatchingStochasticSoilModel_SurfaceLineOverlappingSingleSoilModel_SetsSoilModel() { // Setup PipingStochasticSoilModel soilModel = PipingStochasticSoilModelTestFactory.CreatePipingStochasticSoilModel(); var pipingInput = new TestPipingInput(); // Call PipingInputService.SetMatchingStochasticSoilModel(pipingInput, new[] { soilModel }); // Assert Assert.AreSame(soilModel, pipingInput.StochasticSoilModel); }
public void IntersectsWithSurfaceLineGeometry_SurfaceLineNull_ThrowArgumentNullException() { // Setup PipingStochasticSoilModel soilModel = PipingStochasticSoilModelTestFactory.CreatePipingStochasticSoilModel("A", new[] { new Point2D(1.0, 0.0), new Point2D(5.0, 0.0) }); // Call TestDelegate test = () => soilModel.IntersectsWithSurfaceLineGeometry(null); // Assert var exception = Assert.Throws <ArgumentNullException>(test); Assert.AreEqual("surfaceLine", exception.ParamName); }
public void SetMatchingStochasticSoilModel_SurfaceLineOverlappingMultipleSoilModels_DoesNotSetModel() { // Setup var pipingInput = new TestPipingInput(); PipingStochasticSoilModel soilModel1 = PipingStochasticSoilModelTestFactory.CreatePipingStochasticSoilModel("A"); PipingStochasticSoilModel soilModel2 = PipingStochasticSoilModelTestFactory.CreatePipingStochasticSoilModel("C"); // Call PipingInputService.SetMatchingStochasticSoilModel(pipingInput, new[] { soilModel1, soilModel2 }); // Assert Assert.IsNull(pipingInput.StochasticSoilModel); }
public void UpdateModelWithImportedData_ImportedModelsContainDuplicateNames_ThrowsUpdateDataException() { // Setup PipingStochasticSoilModel[] importedStochasticSoilModels = { PipingStochasticSoilModelTestFactory.CreatePipingStochasticSoilModel("B"), PipingStochasticSoilModelTestFactory.CreatePipingStochasticSoilModel("B") }; var strategy = new PipingStochasticSoilModelReplaceDataStrategy(new PipingFailureMechanism()); // Call TestDelegate test = () => strategy.UpdateModelWithImportedData(importedStochasticSoilModels, "path"); // Assert var exception = Assert.Throws <UpdateDataException>(test); Assert.AreEqual("Stochastische ondergrondmodellen moeten een unieke naam hebben. " + "Gevonden dubbele elementen: B.", exception.Message); }