public void GivenMapLayerWithHydraulicBoundaryLocationsData_WhenSelectedWaveHeightTargetProbabilityIndexUpdatedAndCollectionNotified_ThenMapDataAndSelectedMetaDataAttributeUpdated(
Action <ObservableList <HydraulicBoundaryLocationCalculationsForTargetProbability> > shiftItemAction,
string selectedTargetProbabilityFormat, string expectedSelectedTargetProbabilityFormat)
{
// Given
var mocks = new MockRepository();
var observer = mocks.StrictMock <IObserver>();
observer.Expect(o => o.UpdateObserver());
mocks.ReplayAll();
const double targetProbability = 0.001;
var assessmentSection = new AssessmentSectionStub();
assessmentSection.WaveHeightCalculationsForUserDefinedTargetProbabilities.Clear();
assessmentSection.WaveHeightCalculationsForUserDefinedTargetProbabilities.AddRange(new[]
{
new HydraulicBoundaryLocationCalculationsForTargetProbability(targetProbability),
new HydraulicBoundaryLocationCalculationsForTargetProbability(targetProbability),
new HydraulicBoundaryLocationCalculationsForTargetProbability(targetProbability)
});
var hydraulicBoundaryLocation = new HydraulicBoundaryLocation(1, "test1", 1.0, 2.0);
assessmentSection.SetHydraulicBoundaryLocationCalculations(new[]
{
hydraulicBoundaryLocation
});
using (var mapLayer = new HydraulicBoundaryLocationsMapLayer(assessmentSection))
{
string targetProbabilityString = ProbabilityFormattingHelper.Format(targetProbability);
string selectedProbabilityString = string.Format(selectedTargetProbabilityFormat, targetProbabilityString);
mapLayer.MapData.SelectedMetaDataAttribute = string.Format(waveHeightDisplayNameFormat, selectedProbabilityString);
mapLayer.MapData.NotifyObservers();
mapLayer.MapData.Attach(observer);
// Precondition
MapDataTestHelper.AssertHydraulicBoundaryLocationsMapData(assessmentSection, mapLayer.MapData);
// When
ObservableList <HydraulicBoundaryLocationCalculationsForTargetProbability> waveHeightCalculationsForUserDefinedTargetProbabilities =
assessmentSection.WaveHeightCalculationsForUserDefinedTargetProbabilities;
shiftItemAction(waveHeightCalculationsForUserDefinedTargetProbabilities);
waveHeightCalculationsForUserDefinedTargetProbabilities.NotifyObservers();
// Then
MapDataTestHelper.AssertHydraulicBoundaryLocationsMapData(assessmentSection, mapLayer.MapData);
string expectedSelectedProbabilityString = string.Format(expectedSelectedTargetProbabilityFormat, targetProbabilityString);
Assert.AreEqual(string.Format(waveHeightDisplayNameFormat, expectedSelectedProbabilityString),
mapLayer.MapData.SelectedMetaDataAttribute);
}
mocks.VerifyAll();
}
public void Constructor_WithAllData_DataUpdatedToCollectionOfFilledMapData()
{
// Setup
AssessmentSection assessmentSection = CreateAssessmentSectionWithReferenceLine();
assessmentSection.SetHydraulicBoundaryLocationCalculations(new[]
{
new HydraulicBoundaryLocation(1, "test", 1.0, 2.0)
});
// Call
using (new AssemblyToolCalculatorFactoryConfig())
{
var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance;
AssessmentSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedAssessmentSectionAssemblyCalculator;
CombinedFailureMechanismSectionAssembly[] failureMechanismSectionAssembly =
{
CombinedFailureMechanismSectionAssemblyTestFactory.Create(assessmentSection, 21)
};
calculator.CombinedFailureMechanismSectionAssemblyOutput = new CombinedFailureMechanismSectionAssemblyResultWrapper(
failureMechanismSectionAssembly, AssemblyMethod.BOI3A1, AssemblyMethod.BOI3B1, AssemblyMethod.BOI3C1);
using (var view = new AssemblyResultPerSectionMapView(assessmentSection))
{
// Assert
Assert.IsInstanceOf <MapDataCollection>(view.Map.Data);
MapDataCollection mapData = view.Map.Data;
Assert.IsNotNull(mapData);
Assert.AreEqual(3, mapData.Collection.Count());
IEnumerable <CombinedFailureMechanismSectionAssemblyResult> expectedResults =
AssessmentSectionAssemblyFactory.AssembleCombinedPerFailureMechanismSection(assessmentSection);
AssertCombinedFailureMechanismSectionAssemblyResultMapData(expectedResults,
assessmentSection.ReferenceLine,
mapData.Collection.ElementAt(assemblyResultsIndex));
MapData hydraulicBoundaryLocationsMapData = mapData.Collection.ElementAt(hydraulicBoundaryLocationsIndex);
MapDataTestHelper.AssertHydraulicBoundaryLocationsMapData(assessmentSection, hydraulicBoundaryLocationsMapData);
MapData referenceLineMapData = mapData.Collection.ElementAt(referenceLineIndex);
AssertReferenceLineMapData(assessmentSection.ReferenceLine, referenceLineMapData);
}
}
}
public void Constructor_ExpectedValues()
{
// Setup
var assessmentSection = new AssessmentSectionStub();
assessmentSection.SetHydraulicBoundaryLocationCalculations(new[]
{
new HydraulicBoundaryLocation(1, "test", 1.0, 2.0)
});
// Call
using (var mapLayer = new HydraulicBoundaryLocationsMapLayer(assessmentSection))
{
// Assert
Assert.IsInstanceOf <IDisposable>(mapLayer);
MapDataTestHelper.AssertHydraulicBoundaryLocationsMapData(assessmentSection, mapLayer.MapData);
}
}
public void GivenMapLayerWithHydraulicBoundaryLocationsData_WhenCalculationsForUserDefinedTargetProbabilitiesUpdatedAndNotified_ThenMapDataUpdated(
Func <IAssessmentSection, ObservableList <HydraulicBoundaryLocationCalculationsForTargetProbability> > getTargetProbabilitiesFunc)
{
// Given
var mocks = new MockRepository();
var observer = mocks.StrictMock <IObserver>();
observer.Expect(o => o.UpdateObserver());
mocks.ReplayAll();
var hydraulicBoundaryLocation = new HydraulicBoundaryLocation(1, "test1", 1.0, 2.0);
var assessmentSection = new AssessmentSectionStub();
assessmentSection.SetHydraulicBoundaryLocationCalculations(new[]
{
hydraulicBoundaryLocation
});
using (var mapLayer = new HydraulicBoundaryLocationsMapLayer(assessmentSection))
{
ObservableList <HydraulicBoundaryLocationCalculationsForTargetProbability> targetProbabilities = getTargetProbabilitiesFunc(assessmentSection);
var newTargetProbability = new HydraulicBoundaryLocationCalculationsForTargetProbability(0.1);
newTargetProbability.HydraulicBoundaryLocationCalculations.AddRange(assessmentSection.HydraulicBoundaryDatabase.Locations
.Select(l => new HydraulicBoundaryLocationCalculation(l))
.ToArray());
targetProbabilities.Add(newTargetProbability);
targetProbabilities.NotifyObservers();
mapLayer.MapData.Attach(observer);
// Precondition
MapDataTestHelper.AssertHydraulicBoundaryLocationsMapData(assessmentSection, mapLayer.MapData);
// When
HydraulicBoundaryLocationCalculation calculation = newTargetProbability.HydraulicBoundaryLocationCalculations.First();
calculation.Output = new TestHydraulicBoundaryLocationCalculationOutput(new Random(21).NextDouble());
calculation.NotifyObservers();
// Then
MapDataTestHelper.AssertHydraulicBoundaryLocationsMapData(assessmentSection, mapLayer.MapData);
}
mocks.VerifyAll();
}
public void GivenMapLayerWithHydraulicBoundaryLocationsData_WhenNotSelectedTargetProbabilityRemovedAndNotified_ThenMapDataUpdated(
Func <IAssessmentSection, ObservableList <HydraulicBoundaryLocationCalculationsForTargetProbability> > getTargetProbabilitiesFunc, string displayName)
{
// Given
var mocks = new MockRepository();
var observer = mocks.StrictMock <IObserver>();
observer.Expect(o => o.UpdateObserver());
mocks.ReplayAll();
var hydraulicBoundaryLocation = new HydraulicBoundaryLocation(1, "test1", 1.0, 2.0);
var assessmentSection = new AssessmentSectionStub();
assessmentSection.SetHydraulicBoundaryLocationCalculations(new[]
{
hydraulicBoundaryLocation
});
using (var mapLayer = new HydraulicBoundaryLocationsMapLayer(assessmentSection))
{
ObservableList <HydraulicBoundaryLocationCalculationsForTargetProbability> targetProbabilities = getTargetProbabilitiesFunc(assessmentSection);
HydraulicBoundaryLocationCalculationsForTargetProbability calculationsForTargetProbabilityToRemove = targetProbabilities.First();
HydraulicBoundaryLocationCalculationsForTargetProbability calculationsForTargetProbability = targetProbabilities.Last();
mapLayer.MapData.SelectedMetaDataAttribute = string.Format(displayName, ProbabilityFormattingHelper.Format(calculationsForTargetProbability.TargetProbability));
mapLayer.MapData.NotifyObservers();
mapLayer.MapData.Attach(observer);
// Precondition
MapDataTestHelper.AssertHydraulicBoundaryLocationsMapData(assessmentSection, mapLayer.MapData);
// When
targetProbabilities.Remove(calculationsForTargetProbabilityToRemove);
targetProbabilities.NotifyObservers();
// Then
MapDataTestHelper.AssertHydraulicBoundaryLocationsMapData(assessmentSection, mapLayer.MapData);
Assert.AreEqual(string.Format(displayName, ProbabilityFormattingHelper.Format(calculationsForTargetProbability.TargetProbability)),
mapLayer.MapData.SelectedMetaDataAttribute);
}
mocks.VerifyAll();
}
public void Constructor_WithReferenceLineAndHydraulicBoundaryDatabase_DataUpdatedToCollectionOfFilledMapData()
{
// Setup
var referenceLine = new ReferenceLine();
referenceLine.SetGeometry(new[]
{
new Point2D(1.0, 2.0),
new Point2D(2.0, 1.0)
});
var assessmentSection = new AssessmentSectionStub
{
ReferenceLine = referenceLine
};
assessmentSection.SetHydraulicBoundaryLocationCalculations(new[]
{
new HydraulicBoundaryLocation(1, "test", 1.0, 2.0)
});
// Call
AssessmentSectionExtendedView extendedView = ShowCalculationsView(assessmentSection);
// Assert
Assert.IsInstanceOf <MapDataCollection>(extendedView.Map.Data);
MapDataCollection mapData = extendedView.Map.Data;
Assert.IsNotNull(mapData);
MapData hydraulicBoundaryLocationsMapData = mapData.Collection.ElementAt(hydraulicBoundaryLocationsIndex);
MapDataTestHelper.AssertHydraulicBoundaryLocationsMapData(assessmentSection, hydraulicBoundaryLocationsMapData);
MapData referenceLineMapData = mapData.Collection.ElementAt(referenceLineIndex);
MapDataTestHelper.AssertReferenceLineMapData(referenceLine, referenceLineMapData);
Assert.IsTrue(referenceLineMapData.IsVisible);
}
public void GivenMapLayerWithHydraulicBoundaryLocations_WhenChangingHydraulicBoundaryLocationsDataAndObserversNotified_ThenMapDataUpdated()
{
// Given
var mocks = new MockRepository();
var observer = mocks.StrictMock <IObserver>();
observer.Expect(o => o.UpdateObserver());
mocks.ReplayAll();
var assessmentSection = new AssessmentSectionStub();
assessmentSection.SetHydraulicBoundaryLocationCalculations(new[]
{
new HydraulicBoundaryLocation(1, "test1", 1.0, 2.0)
});
using (var mapLayer = new HydraulicBoundaryLocationsMapLayer(assessmentSection))
{
mapLayer.MapData.Attach(observer);
// Precondition
MapDataTestHelper.AssertHydraulicBoundaryLocationsMapData(assessmentSection, mapLayer.MapData);
// When
assessmentSection.SetHydraulicBoundaryLocationCalculations(new[]
{
new HydraulicBoundaryLocation(2, "test2", 2.0, 3.0)
});
assessmentSection.HydraulicBoundaryDatabase.Locations.NotifyObservers();
// Then
MapDataTestHelper.AssertHydraulicBoundaryLocationsMapData(assessmentSection, mapLayer.MapData);
}
mocks.VerifyAll();
}
public void GivenMapLayerWithHydraulicBoundaryLocationsData_WhenTargetProbabilityUpdatedAndNotified_ThenMapDataUpdated(
Func <IAssessmentSection, ObservableList <HydraulicBoundaryLocationCalculationsForTargetProbability> > getTargetProbabilitiesFunc)
{
// Given
var mocks = new MockRepository();
var observer = mocks.StrictMock <IObserver>();
observer.Expect(o => o.UpdateObserver());
mocks.ReplayAll();
var hydraulicBoundaryLocation = new HydraulicBoundaryLocation(1, "test1", 1.0, 2.0);
var assessmentSection = new AssessmentSectionStub();
assessmentSection.SetHydraulicBoundaryLocationCalculations(new[]
{
hydraulicBoundaryLocation
});
using (var mapLayer = new HydraulicBoundaryLocationsMapLayer(assessmentSection))
{
mapLayer.MapData.Attach(observer);
// Precondition
MapDataTestHelper.AssertHydraulicBoundaryLocationsMapData(assessmentSection, mapLayer.MapData);
// When
ObservableList <HydraulicBoundaryLocationCalculationsForTargetProbability> targetProbabilities = getTargetProbabilitiesFunc(assessmentSection);
targetProbabilities.First().TargetProbability = 0.01;
targetProbabilities.First().NotifyObservers();
// Then
MapDataTestHelper.AssertHydraulicBoundaryLocationsMapData(assessmentSection, mapLayer.MapData);
}
mocks.VerifyAll();
}
public void GivenMapLayerWithHydraulicBoundaryLocationsData_WhenHydraulicBoundaryLocationCalculationUpdatedAndNotified_ThenMapDataUpdated(
Func <IAssessmentSection, HydraulicBoundaryLocationCalculation> getCalculationFunc)
{
// Given
var mocks = new MockRepository();
var observer = mocks.StrictMock <IObserver>();
observer.Expect(o => o.UpdateObserver());
mocks.ReplayAll();
var hydraulicBoundaryLocation = new HydraulicBoundaryLocation(1, "test1", 1.0, 2.0);
var assessmentSection = new AssessmentSectionStub();
assessmentSection.SetHydraulicBoundaryLocationCalculations(new[]
{
hydraulicBoundaryLocation
});
using (var mapLayer = new HydraulicBoundaryLocationsMapLayer(assessmentSection))
{
mapLayer.MapData.Attach(observer);
// Precondition
MapDataTestHelper.AssertHydraulicBoundaryLocationsMapData(assessmentSection, mapLayer.MapData);
// When
HydraulicBoundaryLocationCalculation calculation = getCalculationFunc(assessmentSection);
calculation.Output = new TestHydraulicBoundaryLocationCalculationOutput(new Random(21).NextDouble());
calculation.NotifyObservers();
// Then
MapDataTestHelper.AssertHydraulicBoundaryLocationsMapData(assessmentSection, mapLayer.MapData);
}
mocks.VerifyAll();
}
public void GivenMapLayerWithHydraulicBoundaryLocationsData_WhenFailureMechanismContributionUpdatedAndNotified_ThenMapDataUpdated()
{
// Given
var mocks = new MockRepository();
var observer = mocks.StrictMock <IObserver>();
observer.Expect(o => o.UpdateObserver());
mocks.ReplayAll();
var assessmentSection = new AssessmentSectionStub();
assessmentSection.SetHydraulicBoundaryLocationCalculations(new[]
{
new HydraulicBoundaryLocation(1, "test1", 1.0, 2.0)
});
using (var mapLayer = new HydraulicBoundaryLocationsMapLayer(assessmentSection))
{
mapLayer.MapData.Attach(observer);
// Precondition
MapDataTestHelper.AssertHydraulicBoundaryLocationsMapData(assessmentSection, mapLayer.MapData);
// When
var random = new Random(21);
FailureMechanismContribution contribution = assessmentSection.FailureMechanismContribution;
contribution.MaximumAllowableFloodingProbability = random.NextDouble(0.000001, 0.1);
contribution.SignalFloodingProbability = contribution.MaximumAllowableFloodingProbability - 0.000001;
contribution.NotifyObservers();
// Then
MapDataTestHelper.AssertHydraulicBoundaryLocationsMapData(assessmentSection, mapLayer.MapData);
}
mocks.VerifyAll();
}
public void Constructor_WithAllData_DataUpdatedToCollectionOfFilledMapData()
{
// Setup
PipingStochasticSoilModel stochasticSoilModel1 = PipingStochasticSoilModelTestFactory.CreatePipingStochasticSoilModel("name1", new[]
{
new Point2D(1.0, 2.0),
new Point2D(1.1, 2.2)
});
PipingStochasticSoilModel stochasticSoilModel2 = PipingStochasticSoilModelTestFactory.CreatePipingStochasticSoilModel("name2", new[]
{
new Point2D(3.0, 4.0),
new Point2D(3.3, 4.4)
});
var surfaceLineA = new PipingSurfaceLine("Line A");
surfaceLineA.SetGeometry(new[]
{
new Point3D(0.0, 0.0, 1.0),
new Point3D(3.0, 0.0, 1.7)
});
var surfaceLineB = new PipingSurfaceLine("Name B");
surfaceLineB.SetGeometry(new[]
{
new Point3D(0.0, 0.0, 1.5),
new Point3D(3.0, 0.0, 1.8)
});
surfaceLineA.ReferenceLineIntersectionWorldPoint = new Point2D(1.3, 1.3);
surfaceLineB.ReferenceLineIntersectionWorldPoint = new Point2D(1.5, 1.5);
var failureMechanism = new PipingFailureMechanism();
const string arbitraryFilePath = "path";
var geometryPoints = new[]
{
new Point2D(0.0, 0.0),
new Point2D(2.0, 0.0),
new Point2D(4.0, 4.0),
new Point2D(6.0, 4.0)
};
failureMechanism.SurfaceLines.AddRange(new[]
{
surfaceLineA,
surfaceLineB
}, arbitraryFilePath);
FailureMechanismTestHelper.SetSections(failureMechanism, new[]
{
new FailureMechanismSection("A", geometryPoints.Take(2)),
new FailureMechanismSection("B", geometryPoints.Skip(1).Take(2)),
new FailureMechanismSection("C", geometryPoints.Skip(2).Take(2))
});
failureMechanism.StochasticSoilModels.AddRange(new[]
{
stochasticSoilModel1,
stochasticSoilModel2
}, arbitraryFilePath);
var hydraulicBoundaryLocation1 = new HydraulicBoundaryLocation(1, "test", 1.0, 2.0);
var hydraulicBoundaryLocation2 = new HydraulicBoundaryLocation(2, "test", 3.0, 4.0);
var calculationA =
SemiProbabilisticPipingCalculationTestFactory.CreateCalculationWithValidInput <SemiProbabilisticPipingCalculationScenario>(
hydraulicBoundaryLocation1);
var calculationB =
ProbabilisticPipingCalculationTestFactory.CreateCalculationWithValidInput <ProbabilisticPipingCalculationScenario>(
hydraulicBoundaryLocation2);
calculationA.InputParameters.SurfaceLine = surfaceLineA;
calculationB.InputParameters.SurfaceLine = surfaceLineB;
failureMechanism.CalculationsGroup.Children.Add(calculationA);
failureMechanism.CalculationsGroup.Children.Add(calculationB);
var referenceLine = new ReferenceLine();
referenceLine.SetGeometry(new[]
{
new Point2D(0.0, 3.0),
new Point2D(3.0, 0.0)
});
var assessmentSection = new AssessmentSectionStub
{
ReferenceLine = referenceLine
};
assessmentSection.SetHydraulicBoundaryLocationCalculations(new[]
{
hydraulicBoundaryLocation1,
hydraulicBoundaryLocation2
});
using (new AssemblyToolCalculatorFactoryConfig())
{
// Call
PipingFailureMechanismView view = CreateView(failureMechanism, assessmentSection);
IMapControl map = ((RiskeerMapControl)view.Controls[0]).MapControl;
// Assert
MapDataCollection mapData = map.Data;
Assert.IsInstanceOf <MapDataCollection>(mapData);
List <MapData> mapDataList = mapData.Collection.ToList();
Assert.AreEqual(8, mapDataList.Count);
MapDataTestHelper.AssertReferenceLineMapData(assessmentSection.ReferenceLine, mapDataList[referenceLineIndex]);
AssertSurfaceLinesMapData(failureMechanism.SurfaceLines, mapDataList[surfaceLinesIndex]);
IEnumerable <MapData> sectionsCollection = ((MapDataCollection)mapDataList[sectionsCollectionIndex]).Collection;
MapDataTestHelper.AssertFailureMechanismSectionsMapData(failureMechanism.Sections, sectionsCollection.ElementAt(sectionsIndex));
MapDataTestHelper.AssertFailureMechanismSectionsStartPointMapData(failureMechanism.Sections, sectionsCollection.ElementAt(sectionsStartPointIndex));
MapDataTestHelper.AssertFailureMechanismSectionsEndPointMapData(failureMechanism.Sections, sectionsCollection.ElementAt(sectionsEndPointIndex));
MapDataTestHelper.AssertHydraulicBoundaryLocationsMapData(assessmentSection, mapDataList[hydraulicBoundaryLocationsIndex]);
AssertStochasticSoilModelsMapData(failureMechanism.StochasticSoilModels, mapDataList[stochasticSoilModelsIndex]);
AssertProbabilisticCalculationsMapData(failureMechanism.Calculations.OfType <ProbabilisticPipingCalculationScenario>(), mapDataList[probabilisticCalculationsIndex]);
AssertSemiProbabilisticCalculationsMapData(failureMechanism.Calculations.OfType <SemiProbabilisticPipingCalculationScenario>(), mapDataList[semiProbabilisticCalculationsIndex]);
var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance;
FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator;
MapDataTestHelper.AssertAssemblyMapData(failureMechanism, calculator.FailureMechanismSectionAssemblyResultOutput.AssemblyResult, mapDataList[assemblyResultsIndex]);
}
}
public void Constructor_WithAllData_DataUpdatedToCollectionOfFilledMapData()
{
// Setup
var calculationA = new StabilityStoneCoverWaveConditionsCalculation
{
InputParameters =
{
ForeshoreProfile = new TestForeshoreProfile(new Point2D(1.3, 1.3)),
HydraulicBoundaryLocation = new TestHydraulicBoundaryLocation()
}
};
var calculationB = new StabilityStoneCoverWaveConditionsCalculation
{
InputParameters =
{
ForeshoreProfile = new TestForeshoreProfile(new Point2D(1.5, 1.5)),
HydraulicBoundaryLocation = new TestHydraulicBoundaryLocation()
}
};
var geometryPoints = new[]
{
new Point2D(0.0, 0.0),
new Point2D(2.0, 0.0),
new Point2D(4.0, 4.0),
new Point2D(6.0, 4.0)
};
var failureMechanism = new StabilityStoneCoverFailureMechanism();
FailureMechanismTestHelper.SetSections(failureMechanism, new[]
{
new FailureMechanismSection("A", geometryPoints.Take(2)),
new FailureMechanismSection("B", geometryPoints.Skip(1).Take(2)),
new FailureMechanismSection("C", geometryPoints.Skip(2).Take(2))
});
var profile1 = new TestForeshoreProfile("profile1 ID", new[]
{
new Point2D(0, 0),
new Point2D(1, 1)
});
var profile2 = new TestForeshoreProfile("profile2 ID", new[]
{
new Point2D(2, 2),
new Point2D(3, 3)
});
failureMechanism.ForeshoreProfiles.AddRange(new[]
{
profile1,
profile2
}, "path");
failureMechanism.CalculationsGroup.Children.Add(calculationA);
failureMechanism.CalculationsGroup.Children.Add(calculationB);
var referenceLine = new ReferenceLine();
referenceLine.SetGeometry(new[]
{
new Point2D(1.0, 2.0),
new Point2D(2.0, 1.0)
});
var assessmentSection = new AssessmentSectionStub
{
ReferenceLine = referenceLine
};
assessmentSection.SetHydraulicBoundaryLocationCalculations(new[]
{
new HydraulicBoundaryLocation(1, "test", 1.0, 2.0)
});
// Call
StabilityStoneCoverFailureMechanismView view = CreateView(failureMechanism, assessmentSection);
IMapControl map = ((RiskeerMapControl)view.Controls[0]).MapControl;
// Assert
MapDataCollection mapData = map.Data;
Assert.IsInstanceOf <MapDataCollection>(mapData);
List <MapData> mapDataList = mapData.Collection.ToList();
Assert.AreEqual(4, mapDataList.Count);
MapDataTestHelper.AssertReferenceLineMapData(assessmentSection.ReferenceLine, mapDataList[referenceLineIndex]);
MapDataTestHelper.AssertHydraulicBoundaryLocationsMapData(assessmentSection, mapDataList[hydraulicBoundaryLocationsIndex]);
MapDataTestHelper.AssertForeshoreProfilesMapData(failureMechanism.ForeshoreProfiles, mapDataList[foreshoreProfilesIndex]);
AssertCalculationsMapData(failureMechanism.Calculations.Cast <StabilityStoneCoverWaveConditionsCalculation>(), mapDataList[calculationsIndex]);
}
public void Constructor_WithAllData_DataUpdatedToCollectionOfFilledMapData()
{
// Setup
MacroStabilityInwardsStochasticSoilModel stochasticSoilModel1 =
MacroStabilityInwardsStochasticSoilModelTestFactory.CreateValidStochasticSoilModel("name1", new[]
{
new Point2D(1.0, 2.0),
new Point2D(1.1, 2.2)
});
MacroStabilityInwardsStochasticSoilModel stochasticSoilModel2 =
MacroStabilityInwardsStochasticSoilModelTestFactory.CreateValidStochasticSoilModel("name2", new[]
{
new Point2D(3.0, 4.0),
new Point2D(3.3, 4.4)
});
var surfaceLineA = new MacroStabilityInwardsSurfaceLine("Line A");
surfaceLineA.SetGeometry(new[]
{
new Point3D(0.0, 0.0, 1.0),
new Point3D(3.0, 0.0, 1.7)
});
var surfaceLineB = new MacroStabilityInwardsSurfaceLine("Name B");
surfaceLineB.SetGeometry(new[]
{
new Point3D(0.0, 0.0, 1.5),
new Point3D(3.0, 0.0, 1.8)
});
surfaceLineA.ReferenceLineIntersectionWorldPoint = new Point2D(1.3, 1.3);
surfaceLineB.ReferenceLineIntersectionWorldPoint = new Point2D(1.5, 1.5);
var geometryPoints = new[]
{
new Point2D(0.0, 0.0),
new Point2D(2.0, 0.0),
new Point2D(4.0, 4.0),
new Point2D(6.0, 4.0)
};
var failureMechanism = new MacroStabilityInwardsFailureMechanism();
const string arbitraryFilePath = "path";
failureMechanism.SurfaceLines.AddRange(new[]
{
surfaceLineA,
surfaceLineB
}, arbitraryFilePath);
FailureMechanismTestHelper.SetSections(failureMechanism, new[]
{
new FailureMechanismSection("A", geometryPoints.Take(2)),
new FailureMechanismSection("B", geometryPoints.Skip(1).Take(2)),
new FailureMechanismSection("C", geometryPoints.Skip(2).Take(2))
});
failureMechanism.StochasticSoilModels.AddRange(new[]
{
stochasticSoilModel1,
stochasticSoilModel2
}, arbitraryFilePath);
var hydraulicBoundaryLocation1 = new HydraulicBoundaryLocation(1, "test", 1.0, 2.0);
var hydraulicBoundaryLocation2 = new HydraulicBoundaryLocation(2, "test", 3.0, 4.0);
MacroStabilityInwardsCalculationScenario calculationA = MacroStabilityInwardsCalculationScenarioTestFactory.CreateMacroStabilityInwardsCalculationScenarioWithValidInput(hydraulicBoundaryLocation1);
calculationA.InputParameters.SurfaceLine = surfaceLineA;
MacroStabilityInwardsCalculationScenario calculationB = MacroStabilityInwardsCalculationScenarioTestFactory.CreateMacroStabilityInwardsCalculationScenarioWithValidInput(hydraulicBoundaryLocation2);
calculationB.InputParameters.SurfaceLine = surfaceLineB;
failureMechanism.CalculationsGroup.Children.Add(calculationA);
failureMechanism.CalculationsGroup.Children.Add(calculationB);
var referenceLine = new ReferenceLine();
referenceLine.SetGeometry(new[]
{
new Point2D(0.0, 3.0),
new Point2D(3.0, 0.0)
});
var assessmentSection = new AssessmentSectionStub
{
ReferenceLine = referenceLine
};
assessmentSection.SetHydraulicBoundaryLocationCalculations(new[]
{
hydraulicBoundaryLocation1,
hydraulicBoundaryLocation2
});
// Call
MacroStabilityInwardsFailureMechanismView view = CreateView(failureMechanism, assessmentSection);
IMapControl map = ((RiskeerMapControl)view.Controls[0]).MapControl;
// Assert
MapDataCollection mapData = map.Data;
Assert.IsInstanceOf <MapDataCollection>(mapData);
List <MapData> mapDataList = mapData.Collection.ToList();
Assert.AreEqual(5, mapDataList.Count);
MapDataTestHelper.AssertReferenceLineMapData(assessmentSection.ReferenceLine, mapDataList[referenceLineIndex]);
AssertSurfaceLinesMapData(failureMechanism.SurfaceLines, mapDataList[surfaceLinesIndex]);
MapDataTestHelper.AssertHydraulicBoundaryLocationsMapData(assessmentSection, mapDataList[hydraulicBoundaryLocationsIndex]);
AssertStochasticSoilModelsMapData(failureMechanism.StochasticSoilModels, mapDataList[stochasticSoilModelsIndex]);
AssertCalculationsMapData(failureMechanism.Calculations.Cast <MacroStabilityInwardsCalculationScenario>(), mapDataList[calculationsIndex]);
}
public void Constructor_WithAllData_DataUpdatedToCollectionOfFilledMapData()
{
// Setup
var calculationA = new StructuresCalculationScenario <StabilityPointStructuresInput>
{
InputParameters =
{
HydraulicBoundaryLocation = new HydraulicBoundaryLocation(1, string.Empty, 1.3, 2.3),
Structure = new TestStabilityPointStructure(new Point2D(1.2, 2.3))
}
};
var calculationB = new StructuresCalculationScenario <StabilityPointStructuresInput>
{
InputParameters =
{
HydraulicBoundaryLocation = new HydraulicBoundaryLocation(1, string.Empty, 7.7, 12.6),
Structure = new TestStabilityPointStructure(new Point2D(2.7, 2.0))
}
};
var geometryPoints = new[]
{
new Point2D(0.0, 0.0),
new Point2D(2.0, 0.0),
new Point2D(4.0, 4.0),
new Point2D(6.0, 4.0)
};
var failureMechanism = new StabilityPointStructuresFailureMechanism();
FailureMechanismTestHelper.SetSections(failureMechanism, new[]
{
new FailureMechanismSection("A", geometryPoints.Take(2)),
new FailureMechanismSection("B", geometryPoints.Skip(1).Take(2)),
new FailureMechanismSection("C", geometryPoints.Skip(2).Take(2))
});
var profile1 = new TestForeshoreProfile("profile1 ID", new[]
{
new Point2D(0, 0),
new Point2D(1, 1)
});
var profile2 = new TestForeshoreProfile("profile2 ID", new[]
{
new Point2D(2, 2),
new Point2D(3, 3)
});
failureMechanism.ForeshoreProfiles.AddRange(new[]
{
profile1,
profile2
}, "path");
failureMechanism.CalculationsGroup.Children.Add(calculationA);
failureMechanism.CalculationsGroup.Children.Add(calculationB);
var referenceLine = new ReferenceLine();
referenceLine.SetGeometry(new[]
{
new Point2D(1.0, 2.0),
new Point2D(2.0, 1.0)
});
var assessmentSection = new AssessmentSectionStub
{
ReferenceLine = referenceLine
};
assessmentSection.SetHydraulicBoundaryLocationCalculations(new[]
{
new HydraulicBoundaryLocation(1, "test", 1.0, 2.0)
});
using (new AssemblyToolCalculatorFactoryConfig())
{
// Call
StabilityPointStructuresFailureMechanismView view = CreateView(failureMechanism, assessmentSection);
IMapControl map = ((RiskeerMapControl)view.Controls[0]).MapControl;
// Assert
MapDataCollection mapData = map.Data;
Assert.IsInstanceOf <MapDataCollection>(mapData);
List <MapData> mapDataList = mapData.Collection.ToList();
Assert.AreEqual(7, mapDataList.Count);
MapDataTestHelper.AssertReferenceLineMapData(assessmentSection.ReferenceLine, mapDataList[referenceLineIndex]);
IEnumerable <MapData> sectionsCollection = ((MapDataCollection)mapDataList[sectionsCollectionIndex]).Collection;
MapDataTestHelper.AssertFailureMechanismSectionsMapData(failureMechanism.Sections, sectionsCollection.ElementAt(sectionsIndex));
MapDataTestHelper.AssertFailureMechanismSectionsStartPointMapData(failureMechanism.Sections, sectionsCollection.ElementAt(sectionsStartPointIndex));
MapDataTestHelper.AssertFailureMechanismSectionsEndPointMapData(failureMechanism.Sections, sectionsCollection.ElementAt(sectionsEndPointIndex));
MapDataTestHelper.AssertHydraulicBoundaryLocationsMapData(assessmentSection, mapDataList[hydraulicBoundaryLocationsIndex]);
MapDataTestHelper.AssertForeshoreProfilesMapData(failureMechanism.ForeshoreProfiles, mapDataList[foreshoreProfilesIndex]);
AssertCalculationsMapData(
failureMechanism.Calculations.Cast <StructuresCalculation <StabilityPointStructuresInput> >(),
mapDataList[calculationsIndex]);
var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance;
FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator;
MapDataTestHelper.AssertAssemblyMapData(failureMechanism, calculator.FailureMechanismSectionAssemblyResultOutput.AssemblyResult, mapDataList[assemblyResultsIndex]);
}
}
public void Constructor_WithAllData_DataUpdatedToCollectionOfFilledMapData()
{
// Setup
var referenceLine = new ReferenceLine();
referenceLine.SetGeometry(new[]
{
new Point2D(1.0, 2.0),
new Point2D(2.0, 1.0)
});
var assessmentSection = new AssessmentSectionStub
{
ReferenceLine = referenceLine
};
assessmentSection.SetHydraulicBoundaryLocationCalculations(new[]
{
new HydraulicBoundaryLocation(1, "test", 1.0, 2.0)
});
var geometryPoints = new[]
{
new Point2D(0.0, 0.0),
new Point2D(2.0, 0.0),
new Point2D(4.0, 4.0),
new Point2D(6.0, 4.0)
};
var failureMechanism = new SpecificFailureMechanism();
FailureMechanismTestHelper.SetSections(failureMechanism, new[]
{
new FailureMechanismSection("A", geometryPoints.Take(2)),
new FailureMechanismSection("B", geometryPoints.Skip(1).Take(2)),
new FailureMechanismSection("C", geometryPoints.Skip(2).Take(2))
});
using (new AssemblyToolCalculatorFactoryConfig())
{
// Call
SpecificFailureMechanismView view = CreateView(failureMechanism, assessmentSection);
// Assert
MapDataCollection mapData = view.Map.Data;
List <MapData> mapDataList = mapData.Collection.ToList();
Assert.AreEqual(4, mapDataList.Count);
MapDataTestHelper.AssertReferenceLineMapData(assessmentSection.ReferenceLine, mapDataList[referenceLineIndex]);
IEnumerable <MapData> sectionsCollection = ((MapDataCollection)mapDataList[sectionsCollectionIndex]).Collection;
MapDataTestHelper.AssertFailureMechanismSectionsMapData(failureMechanism.Sections, sectionsCollection.ElementAt(sectionsIndex));
MapDataTestHelper.AssertFailureMechanismSectionsStartPointMapData(failureMechanism.Sections, sectionsCollection.ElementAt(sectionsStartPointIndex));
MapDataTestHelper.AssertFailureMechanismSectionsEndPointMapData(failureMechanism.Sections, sectionsCollection.ElementAt(sectionsEndPointIndex));
var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance;
FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator;
MapDataTestHelper.AssertAssemblyMapData(failureMechanism, calculator.FailureMechanismSectionAssemblyResultOutput.AssemblyResult, mapDataList[assemblyResultsIndex]);
MapDataTestHelper.AssertHydraulicBoundaryLocationsMapData(assessmentSection, mapDataList[hydraulicBoundaryLocationsIndex]);
}
}
public void Constructor_WithAllData_DataUpdatedToCollectionOfFilledMapData()
{
// Setup
var geometryPoints = new[]
{
new Point2D(0.0, 0.0),
new Point2D(2.0, 0.0),
new Point2D(4.0, 4.0),
new Point2D(6.0, 4.0)
};
var referenceLine = new ReferenceLine();
referenceLine.SetGeometry(new[]
{
new Point2D(1.0, 2.0),
new Point2D(2.0, 1.0)
});
var assessmentSection = new AssessmentSectionStub
{
ReferenceLine = referenceLine
};
assessmentSection.SetHydraulicBoundaryLocationCalculations(new[]
{
new HydraulicBoundaryLocation(1, "test", 1.0, 2.0)
});
var failureMechanism = new TestFailureMechanism();
FailureMechanismTestHelper.SetSections(failureMechanism, new[]
{
new FailureMechanismSection("A", geometryPoints.Take(2)),
new FailureMechanismSection("B", geometryPoints.Skip(1).Take(2)),
new FailureMechanismSection("C", geometryPoints.Skip(2).Take(2))
});
var random = new Random(21);
var failureMechanismSectionAssemblyResult = new FailureMechanismSectionAssemblyResult(
random.NextDouble(), random.NextDouble(), random.NextDouble(),
random.NextEnumValue <FailureMechanismSectionAssemblyGroup>());
// Call
using (var view = new StandAloneFailureMechanismView <IFailureMechanism <FailureMechanismSectionResult>, FailureMechanismSectionResult>(
failureMechanism, assessmentSection, sr => failureMechanismSectionAssemblyResult))
{
IMapControl map = ((RiskeerMapControl)view.Controls[0]).MapControl;
// Assert
MapDataCollection mapData = map.Data;
Assert.IsInstanceOf <MapDataCollection>(mapData);
List <MapData> mapDataList = mapData.Collection.ToList();
Assert.AreEqual(4, mapDataList.Count);
MapDataTestHelper.AssertReferenceLineMapData(assessmentSection.ReferenceLine, mapDataList[referenceLineIndex]);
IEnumerable <MapData> sectionsCollection = ((MapDataCollection)mapDataList[sectionsCollectionIndex]).Collection;
MapDataTestHelper.AssertFailureMechanismSectionsMapData(failureMechanism.Sections, sectionsCollection.ElementAt(sectionsIndex));
MapDataTestHelper.AssertFailureMechanismSectionsStartPointMapData(failureMechanism.Sections, sectionsCollection.ElementAt(sectionsStartPointIndex));
MapDataTestHelper.AssertFailureMechanismSectionsEndPointMapData(failureMechanism.Sections, sectionsCollection.ElementAt(sectionsEndPointIndex));
MapDataTestHelper.AssertHydraulicBoundaryLocationsMapData(assessmentSection, mapDataList[hydraulicBoundaryLocationsIndex]);
MapDataTestHelper.AssertAssemblyMapData(failureMechanism, failureMechanismSectionAssemblyResult, mapDataList[assemblyResultsIndex]);
}
}