public void Create_WithValidCollection_ReturnsEntityWithExpectedResults() { // Setup var random = new Random(21); int order = random.Next(); var duneLocation = new TestDuneLocation(); var calculation = new DuneLocationCalculation(duneLocation); var calculations = new DuneLocationCalculationsForTargetProbability(random.NextDouble(0, 0.1)) { DuneLocationCalculations = { calculation } }; var duneLocationEntity = new DuneLocationEntity(); var registry = new PersistenceRegistry(); registry.Register(duneLocationEntity, duneLocation); // Call DuneLocationCalculationForTargetProbabilityCollectionEntity entity = calculations.Create(order, registry); // Assert Assert.IsNotNull(entity); Assert.AreEqual(order, entity.Order); Assert.AreEqual(calculations.TargetProbability, entity.TargetProbability); DuneLocationCalculationEntity duneLocationCalculationEntity = entity.DuneLocationCalculationEntities.Single(); Assert.AreSame(duneLocationEntity, duneLocationCalculationEntity.DuneLocationEntity); CollectionAssert.IsEmpty(duneLocationCalculationEntity.DuneLocationCalculationOutputEntities); }
public void GivenDisposedPropertyControlWithData_WhenSingleCalculationUpdated_RefreshRequiredEventNotRaised() { // Given var mocks = new MockRepository(); var targetProbabilityChangeHandler = mocks.Stub <IObservablePropertyChangeHandler>(); mocks.ReplayAll(); var calculation = new DuneLocationCalculation(new TestDuneLocation()); var calculationsForTargetProbability = new DuneLocationCalculationsForTargetProbability(0.1) { DuneLocationCalculations = { calculation } }; using (var properties = new DuneLocationCalculationsForUserDefinedTargetProbabilityProperties(calculationsForTargetProbability, targetProbabilityChangeHandler)) { var refreshRequiredRaised = 0; properties.RefreshRequired += (sender, args) => refreshRequiredRaised++; properties.Dispose(); // When calculation.NotifyObservers(); // Then Assert.AreEqual(0, refreshRequiredRaised); mocks.VerifyAll(); } }
public void Constructor_WithData_ReturnExpectedValues() { // Setup var mocks = new MockRepository(); var targetProbabilityChangeHandler = mocks.Stub <IObservablePropertyChangeHandler>(); mocks.ReplayAll(); var calculation = new DuneLocationCalculation(new TestDuneLocation()); var calculationsForTargetProbability = new DuneLocationCalculationsForTargetProbability(0.1) { DuneLocationCalculations = { calculation } }; // Call using (var properties = new DuneLocationCalculationsForUserDefinedTargetProbabilityProperties(calculationsForTargetProbability, targetProbabilityChangeHandler)) { // Assert Assert.IsInstanceOf <ObjectProperties <DuneLocationCalculationsForTargetProbability> >(properties); Assert.IsInstanceOf <IDisposable>(properties); Assert.AreSame(calculationsForTargetProbability, properties.Data); Assert.AreEqual(calculationsForTargetProbability.TargetProbability, properties.TargetProbability); Assert.AreEqual(1, properties.Calculations.Length); Assert.AreSame(calculation, properties.Calculations[0].Data); mocks.VerifyAll(); } }
private static DuneLocationCalculation CreateDuneLocationCalculation(DuneLocationCalculationEntity calculationEntity, ReadConversionCollector collector) { var calculation = new DuneLocationCalculation(collector.Get(calculationEntity.DuneLocationEntity)); calculationEntity.Read(calculation); return(calculation); }
public void Read_EntityWithValidValues_SetsCalculationsWithExpectedValues() { // Setup var random = new Random(21); var duneLocationEntityOne = new DuneLocationEntity(); var calculationEntityWithoutOutput = new DuneLocationCalculationEntity { DuneLocationEntity = duneLocationEntityOne }; var duneLocationEntityTwo = new DuneLocationEntity(); var calculationEntityWithOutput = new DuneLocationCalculationEntity { DuneLocationEntity = duneLocationEntityTwo, DuneLocationCalculationOutputEntities = { new DuneLocationCalculationOutputEntity() } }; var collectionEntity = new DuneLocationCalculationForTargetProbabilityCollectionEntity { TargetProbability = random.NextDouble(0, 0.1), DuneLocationCalculationEntities = { calculationEntityWithoutOutput, calculationEntityWithOutput } }; var duneLocationOne = new TestDuneLocation("1"); var duneLocationTwo = new TestDuneLocation("2"); var collector = new ReadConversionCollector(); collector.Read(duneLocationEntityOne, duneLocationOne); collector.Read(duneLocationEntityTwo, duneLocationTwo); // Call DuneLocationCalculationsForTargetProbability calculations = collectionEntity.Read(collector); // Assert Assert.AreEqual(collectionEntity.TargetProbability, calculations.TargetProbability); IEnumerable <DuneLocationCalculation> duneLocationCalculations = calculations.DuneLocationCalculations; Assert.AreEqual(collectionEntity.DuneLocationCalculationEntities.Count, duneLocationCalculations.Count()); DuneLocationCalculation calculationOne = duneLocationCalculations.ElementAt(0); Assert.AreSame(collector.Get(duneLocationEntityOne), calculationOne.DuneLocation); Assert.IsNull(calculationOne.Output); DuneLocationCalculation calculationTwo = duneLocationCalculations.ElementAt(1); Assert.AreSame(collector.Get(duneLocationEntityTwo), calculationTwo.DuneLocation); Assert.IsNotNull(calculationTwo.Output); }
public void GivenFullyConfiguredDuneLocationCalculationsView_WhenDuneLocationCalculationsUpdatedAndNotified_ThenDataGridCorrectlyUpdated() { // Given var assessmentSection = mocks.Stub <IAssessmentSection>(); mocks.ReplayAll(); var calculations = new ObservableList <DuneLocationCalculation>(); using (DuneLocationCalculationsView view = ShowDuneLocationCalculationsView(calculations, new DuneErosionFailureMechanism(), assessmentSection)) { // Precondition var dataGridView = (DataGridView)view.Controls.Find("dataGridView", true)[0]; object originalDataSource = dataGridView.DataSource; DataGridViewRowCollection rows = dataGridView.Rows; Assert.AreEqual(0, rows.Count); // When var duneLocation = new DuneLocation(10, "10", new Point2D(10.0, 10.0), new DuneLocation.ConstructionProperties { CoastalAreaId = 3, Offset = 80, D50 = 0.000321 }); var duneLocationCalculation = new DuneLocationCalculation(duneLocation) { Output = new DuneLocationCalculationOutput(CalculationConvergence.CalculatedConverged, new DuneLocationCalculationOutput.ConstructionProperties { WaterLevel = 3.21, WaveHeight = 4.32, WavePeriod = 5.43 }) }; calculations.Add(duneLocationCalculation); calculations.NotifyObservers(); // Then Assert.AreNotSame(originalDataSource, dataGridView.DataSource); var expectedRowValues = new object[] { false, "10", "10", new Point2D(10, 10).ToString(), "3", "80", 3.21.ToString(CultureInfo.CurrentCulture), 4.32.ToString(CultureInfo.CurrentCulture), 5.43.ToString(CultureInfo.CurrentCulture), 0.000321.ToString(CultureInfo.CurrentCulture) }; DataGridViewTestHelper.AssertExpectedRowFormattedValues(expectedRowValues, rows[0]); } }
/// <summary> /// Creates a new instance of <see cref="ExportableDuneLocationCalculation"/>. /// </summary> /// <param name="calculation">The <see cref="DuneLocationCalculation"/> that will be exported.</param> /// <param name="targetProbability">The target probability belonging to the calculation.</param> /// <exception cref="ArgumentNullException">Thrown when <paramref name="calculation"/> is <c>null</c>.</exception> public ExportableDuneLocationCalculation(DuneLocationCalculation calculation, double targetProbability) { if (calculation == null) { throw new ArgumentNullException(nameof(calculation)); } Calculation = calculation; TargetProbability = targetProbability; }
private static DuneLocationCalculation CreateCalculation(bool hasOutput = false) { var calculation = new DuneLocationCalculation(new TestDuneLocation()); if (hasOutput) { calculation.Output = new TestDuneLocationCalculationOutput(); } return(calculation); }
public DuneLocationCalculationActivityWithState(DuneLocationCalculation duneLocationCalculation, HydraulicBoundaryCalculationSettings calculationSettings, double targetProbability, string calculationIdentifier, ActivityState state) : base(duneLocationCalculation, calculationSettings, targetProbability, calculationIdentifier) { State = state; }
public void Read_CalculationEntityWithOutput_SetsDuneLocationCalculationWithoutOutput() { // Setup var calculation = new DuneLocationCalculation(new TestDuneLocation()); var entity = new DuneLocationCalculationEntity(); // Call entity.Read(calculation); // Assert Assert.IsNull(calculation.Output); }
public void Create_PersistenceRegistryNull_ThrowsArgumentNullException() { // Setup var calculation = new DuneLocationCalculation(new TestDuneLocation()); // Call TestDelegate call = () => calculation.Create(null); // Assert var exception = Assert.Throws <ArgumentNullException>(call); Assert.AreEqual("registry", exception.ParamName); }
public void Constructor_DuneLocationCalculationWithoutOutput_ExpectedValues() { // Setup var duneLocationCalculation = new DuneLocationCalculation(new TestDuneLocation()); // Call var row = new DuneLocationCalculationRow(duneLocationCalculation); // Assert Assert.IsNaN(row.WaterLevel); Assert.IsNaN(row.WaveHeight); Assert.IsNaN(row.WavePeriod); }
public void Constructor_WithValidParameters_ExpectedProperties() { // Setup var calculation = new DuneLocationCalculation(new TestDuneLocation()); double targetProbability = new Random(39).NextDouble(); // Call var exportableCalculation = new ExportableDuneLocationCalculation(calculation, targetProbability); // Assert Assert.AreSame(calculation, exportableCalculation.Calculation); Assert.AreEqual(targetProbability, exportableCalculation.TargetProbability); }
public void Read_EntityNull_ThrowsArgumentNullException() { // Setup var calculation = new DuneLocationCalculation(new TestDuneLocation()); // Call TestDelegate call = () => ((DuneLocationCalculationEntity)null).Read(calculation); // Assert var exception = Assert.Throws <ArgumentNullException>(call); Assert.AreEqual("entity", exception.ParamName); }
public void ToString_Always_ExpectedValue() { // Setup var duneLocation = new DuneLocation(1, "Name", new Point2D(0.0, 1.1), new DuneLocation.ConstructionProperties()); var duneLocationCalculation = new DuneLocationCalculation(duneLocation); var properties = new DuneLocationCalculationProperties(duneLocationCalculation); // Call string result = properties.ToString(); // Assert Assert.AreEqual($"{duneLocation.Name} {duneLocation.Location}", result); }
public void Calculate_CalculationRanNotConverged_LogMessage() { // Setup const double targetProbability = 1.0 / 30; const string locationName = "locationName"; const string failedConvergenceMessage = "failedConvergenceMessage"; var calculator = new TestDunesBoundaryConditionsCalculator { ReliabilityIndex = 0.01 }; var mockRepository = new MockRepository(); var calculatorFactory = mockRepository.StrictMock <IHydraRingCalculatorFactory>(); calculatorFactory.Expect(cf => cf.CreateDunesBoundaryConditionsCalculator(null)) .IgnoreArguments() .Return(calculator); var calculationMessageProvider = mockRepository.StrictMock <ICalculationMessageProvider>(); calculationMessageProvider.Expect(c => c.GetCalculatedNotConvergedMessage(locationName)).Return(failedConvergenceMessage); mockRepository.ReplayAll(); var duneLocation = new TestDuneLocation(locationName); var duneLocationCalculation = new DuneLocationCalculation(duneLocation); using (new HydraRingCalculatorFactoryConfig(calculatorFactory)) { // Call Action test = () => new DuneLocationCalculationService().Calculate(duneLocationCalculation, targetProbability, CreateCalculationSettings(), calculationMessageProvider); // Assert TestHelper.AssertLogMessages( test, messages => { string[] msgs = messages.ToArray(); Assert.AreEqual(4, msgs.Length); CalculationServiceTestHelper.AssertCalculationStartMessage(msgs[0]); Assert.AreEqual(failedConvergenceMessage, msgs[1]); StringAssert.StartsWith("Hydraulische belastingenberekening is uitgevoerd op de tijdelijke locatie", msgs[2]); CalculationServiceTestHelper.AssertCalculationEndMessage(msgs[3]); }); } mockRepository.VerifyAll(); }
public void ShouldCalculate_OutputNull_ReturnsTrue() { // Setup var calculation = new DuneLocationCalculation(new TestDuneLocation()) { Output = null }; // Call bool shouldCalculate = calculation.ShouldCalculate; // Assert Assert.IsTrue(shouldCalculate); }
public void ShouldCalculate_OutputSet_ReturnsFalse() { // Setup var calculation = new DuneLocationCalculation(new TestDuneLocation()) { Output = new TestDuneLocationCalculationOutput() }; // Call bool shouldCalculate = calculation.ShouldCalculate; // Assert Assert.IsFalse(shouldCalculate); }
public void Constructor_ExpectedValues() { // Setup var duneLocation = new TestDuneLocation(); // Call var calculation = new DuneLocationCalculation(duneLocation); // Assert Assert.IsInstanceOf <ICalculatable>(calculation); Assert.IsInstanceOf <Observable>(calculation); Assert.AreSame(duneLocation, calculation.DuneLocation); Assert.IsNull(calculation.Output); }
public void Read_CalculationEntityWithOutput_SetsDuneLocationCalculationWithOutput() { // Setup var calculation = new DuneLocationCalculation(new TestDuneLocation()); var random = new Random(21); double waterLevel = random.NextDouble(); double waveHeight = random.NextDouble(); double wavePeriod = random.NextDouble(); double targetProbability = random.NextDouble(); double targetReliability = random.NextDouble(); double calculatedProbability = random.NextDouble(); double calculatedReliability = random.NextDouble(); var convergence = random.NextEnumValue <CalculationConvergence>(); var entity = new DuneLocationCalculationEntity { DuneLocationCalculationOutputEntities = { new DuneLocationCalculationOutputEntity { WaterLevel = waterLevel, WaveHeight = waveHeight, WavePeriod = wavePeriod, TargetProbability = targetProbability, TargetReliability = targetReliability, CalculatedProbability = calculatedProbability, CalculatedReliability = calculatedReliability, CalculationConvergence = Convert.ToByte(convergence) } } }; // Call entity.Read(calculation); // Assert DuneLocationCalculationOutput output = calculation.Output; Assert.IsNotNull(output); Assert.AreEqual(waterLevel, output.WaterLevel, output.WaterLevel.GetAccuracy()); Assert.AreEqual(waveHeight, output.WaveHeight, output.WaveHeight.GetAccuracy()); Assert.AreEqual(wavePeriod, output.WavePeriod, output.WavePeriod.GetAccuracy()); Assert.AreEqual(targetProbability, output.TargetProbability); Assert.AreEqual(targetReliability, output.TargetReliability, output.TargetReliability.GetAccuracy()); Assert.AreEqual(calculatedProbability, output.CalculatedProbability); Assert.AreEqual(calculatedReliability, output.CalculatedReliability, output.CalculatedReliability.GetAccuracy()); Assert.AreEqual(convergence, output.CalculationConvergence); }
public void Offset_Always_FormatToString(double offset, string expectedPropertyValue) { var duneLocation = new DuneLocation(1, "test", new Point2D(0, 0), new DuneLocation.ConstructionProperties { Offset = offset }); var duneLocationCalculation = new DuneLocationCalculation(duneLocation); // Call var properties = new DuneLocationCalculationProperties(duneLocationCalculation); // Assert Assert.AreEqual(expectedPropertyValue, properties.Offset); }
public void Run_ValidCalculationAndRun_SetsOutput() { // Setup var random = new Random(123); double expectedWaterLevel = random.NextDouble(); double expectedWaveHeight = random.NextDouble(); double expectedWavePeriod = random.NextDouble(); double expectedReliabilityIndex = random.NextDouble(); var duneLocationCalculation = new DuneLocationCalculation(new TestDuneLocation()); var calculator = new TestDunesBoundaryConditionsCalculator { WaterLevel = expectedWaterLevel, WaveHeight = expectedWaveHeight, WavePeriod = expectedWavePeriod, ReliabilityIndex = expectedReliabilityIndex, Converged = true }; var calculatorFactory = mockRepository.StrictMock <IHydraRingCalculatorFactory>(); calculatorFactory.Expect(cf => cf.CreateDunesBoundaryConditionsCalculator(null)) .IgnoreArguments() .Return(calculator); mockRepository.ReplayAll(); var activity = new DuneLocationCalculationActivity(duneLocationCalculation, CreateCalculationSettings(), 0.01, "1/100"); using (new HydraRingCalculatorFactoryConfig(calculatorFactory)) { // Call activity.Run(); } // Assert DuneLocationCalculationOutput actualCalculationOutput = duneLocationCalculation.Output; Assert.IsNotNull(actualCalculationOutput); Assert.AreEqual(expectedWaterLevel, actualCalculationOutput.WaterLevel, actualCalculationOutput.WaterLevel.GetAccuracy()); Assert.AreEqual(expectedWaveHeight, actualCalculationOutput.WaveHeight, actualCalculationOutput.WaveHeight.GetAccuracy()); Assert.AreEqual(expectedWavePeriod, actualCalculationOutput.WavePeriod, actualCalculationOutput.WavePeriod.GetAccuracy()); Assert.AreEqual(expectedReliabilityIndex, actualCalculationOutput.CalculatedReliability, actualCalculationOutput.CalculatedReliability.GetAccuracy()); Assert.AreEqual(CalculationConvergence.CalculatedConverged, actualCalculationOutput.CalculationConvergence); mockRepository.VerifyAll(); }
public void CreateInstance_WithDuneLocationCalculation_SetsDuneLocationCalculationAsData() { // Setup var duneLocationCalculation = new DuneLocationCalculation(new TestDuneLocation()); using (var plugin = new DuneErosionPlugin()) { PropertyInfo info = GetInfo(plugin); // Call IObjectProperties objectProperties = info.CreateInstance(duneLocationCalculation); // Assert Assert.IsInstanceOf <DuneLocationCalculationProperties>(objectProperties); Assert.AreSame(duneLocationCalculation, objectProperties.Data); } }
public void Create_CalculationWithoutOutput_ReturnsDuneLocationCalculationEntity() { // Setup var duneLocation = new TestDuneLocation(); var calculation = new DuneLocationCalculation(duneLocation); var registry = new PersistenceRegistry(); var duneLocationEntity = new DuneLocationEntity(); registry.Register(duneLocationEntity, duneLocation); // Call DuneLocationCalculationEntity entity = calculation.Create(registry); // Assert Assert.IsNotNull(entity); CollectionAssert.IsEmpty(entity.DuneLocationCalculationOutputEntities); }
public void Create_CalculationWithAlreadyRegisteredDuneLocation_ReturnsEntityWithDuneLocationEntity() { // Setup var duneLocation = new TestDuneLocation(); var calculation = new DuneLocationCalculation(duneLocation); var registry = new PersistenceRegistry(); var duneLocationEntity = new DuneLocationEntity(); registry.Register(duneLocationEntity, duneLocation); // Call DuneLocationCalculationEntity entity = calculation.Create(registry); // Assert Assert.IsNotNull(entity); Assert.AreSame(duneLocationEntity, entity.DuneLocationEntity); }
/// <summary> /// Reads the <see cref="DuneLocationCalculationEntity"/> and uses the information to update a /// <see cref="DuneLocationCalculation"/>. /// </summary> /// <param name="entity">The <see cref="DuneLocationCalculationEntity"/> to update the /// <see cref="DuneLocationCalculation"/>.</param> /// <param name="calculation">The target of the read operation.</param> /// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception> internal static void Read(this DuneLocationCalculationEntity entity, DuneLocationCalculation calculation) { if (entity == null) { throw new ArgumentNullException(nameof(entity)); } if (calculation == null) { throw new ArgumentNullException(nameof(calculation)); } DuneLocationCalculationOutputEntity duneLocationCalculationOutputEntity = entity.DuneLocationCalculationOutputEntities.SingleOrDefault(); if (duneLocationCalculationOutputEntity != null) { calculation.Output = duneLocationCalculationOutputEntity.Read(); } }
public void Create_CalculationWithOutput_ReturnsDuneLocationCalculationEntityWithOutput() { // Setup var random = new Random(21); var output = new DuneLocationCalculationOutput(random.NextEnumValue <CalculationConvergence>(), new DuneLocationCalculationOutput.ConstructionProperties { WaterLevel = random.NextDouble(), WaveHeight = random.NextDouble(), WavePeriod = random.NextDouble(), CalculatedProbability = random.NextDouble(), CalculatedReliability = random.NextDouble(), TargetProbability = random.NextDouble(), TargetReliability = random.NextDouble() }); var duneLocation = new TestDuneLocation(); var calculation = new DuneLocationCalculation(duneLocation) { Output = output }; var registry = new PersistenceRegistry(); var duneLocationEntity = new DuneLocationEntity(); registry.Register(duneLocationEntity, duneLocation); // Call DuneLocationCalculationEntity entity = calculation.Create(registry); // Assert Assert.IsNotNull(entity); DuneLocationCalculationOutputEntity outputEntity = entity.DuneLocationCalculationOutputEntities.Single(); Assert.AreEqual(output.WaterLevel, outputEntity.WaterLevel, output.WaterLevel.GetAccuracy()); Assert.AreEqual(output.WaveHeight, outputEntity.WaveHeight, output.WaveHeight.GetAccuracy()); Assert.AreEqual(output.WavePeriod, outputEntity.WavePeriod, output.WavePeriod.GetAccuracy()); Assert.AreEqual(output.TargetProbability, outputEntity.TargetProbability); Assert.AreEqual(output.TargetReliability, outputEntity.TargetReliability, output.TargetReliability.GetAccuracy()); Assert.AreEqual(output.CalculatedProbability, outputEntity.CalculatedProbability); Assert.AreEqual(output.CalculatedReliability, outputEntity.CalculatedReliability, output.CalculatedReliability.GetAccuracy()); Assert.AreEqual(Convert.ToByte(output.CalculationConvergence), outputEntity.CalculationConvergence); }
public void Constructor_DuneLocationCalculationWithOutput_ExpectedValues(double offSet) { // Setup var duneLocation = new DuneLocation(1, "test location", new Point2D(3.3, 4.4), new DuneLocation.ConstructionProperties { CoastalAreaId = 2, Offset = offSet, D50 = 0.000183 }); var duneLocationCalculation = new DuneLocationCalculation(duneLocation) { Output = new DuneLocationCalculationOutput(CalculationConvergence.CalculatedConverged, new DuneLocationCalculationOutput.ConstructionProperties { WaterLevel = 3.0, WaveHeight = 4.0, WavePeriod = 5.0 }) }; // Call var row = new DuneLocationCalculationRow(duneLocationCalculation); // Assert Assert.IsInstanceOf <CalculatableRow <DuneLocationCalculation> >(row); Assert.AreSame(duneLocationCalculation, row.CalculatableObject); Assert.AreEqual(duneLocation.Id, row.Id); Assert.AreEqual(duneLocation.Name, row.Name); Assert.AreSame(duneLocation.Location, row.Location); Assert.AreEqual(duneLocation.CoastalAreaId, row.CoastalAreaId); Assert.AreEqual(duneLocation.Offset.ToString("0.#", CultureInfo.InvariantCulture), row.Offset); Assert.AreEqual(duneLocation.D50, row.D50); Assert.AreEqual(duneLocationCalculation.Output.WaterLevel, row.WaterLevel); Assert.AreEqual(duneLocationCalculation.Output.WaveHeight, row.WaveHeight); Assert.AreEqual(duneLocationCalculation.Output.WavePeriod, row.WavePeriod); TestHelper.AssertTypeConverter <DuneLocationCalculationRow, NoValueRoundedDoubleConverter>( nameof(DuneLocationCalculationRow.WaterLevel)); TestHelper.AssertTypeConverter <DuneLocationCalculationRow, NoValueRoundedDoubleConverter>( nameof(DuneLocationCalculationRow.WaveHeight)); TestHelper.AssertTypeConverter <DuneLocationCalculationRow, NoValueRoundedDoubleConverter>( nameof(DuneLocationCalculationRow.WavePeriod)); }
public void Run_CalculationResultingInNoConvergence_LogWarningNoConvergence() { // Setup const string calculationIdentifier = "1/100"; const string locationName = "locationName"; var calculator = new TestDunesBoundaryConditionsCalculator { Converged = false }; var calculatorFactory = mockRepository.StrictMock <IHydraRingCalculatorFactory>(); calculatorFactory.Expect(cf => cf.CreateDunesBoundaryConditionsCalculator(null)) .IgnoreArguments() .Return(calculator); mockRepository.ReplayAll(); var duneLocationCalculation = new DuneLocationCalculation(new TestDuneLocation(locationName)); var activity = new DuneLocationCalculationActivity(duneLocationCalculation, CreateCalculationSettings(), 0.01, calculationIdentifier); using (new HydraRingCalculatorFactoryConfig(calculatorFactory)) { void Call() => activity.Run(); // Assert TestHelper.AssertLogMessages(Call, messages => { string[] msgs = messages.ToArray(); Assert.AreEqual(7, msgs.Length); Assert.AreEqual($"Hydraulische belastingenberekening voor locatie '{locationName}' ({calculationIdentifier}) is niet geconvergeerd.", msgs[4]); }); Assert.AreEqual(CalculationConvergence.CalculatedNotConverged, duneLocationCalculation.Output.CalculationConvergence); } mockRepository.VerifyAll(); }
/// <summary> /// Creates a <see cref="DuneLocationCalculationEntity"/> based on the information of the <see cref="DuneLocationCalculation"/>. /// </summary> /// <param name="calculation">The calculation to create a database entity for.</param> /// <param name="registry">The object keeping track of create operations.</param> /// <returns>A new <see cref="DuneLocationCalculationEntity"/>.</returns> /// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception> internal static DuneLocationCalculationEntity Create(this DuneLocationCalculation calculation, PersistenceRegistry registry) { if (calculation == null) { throw new ArgumentNullException(nameof(calculation)); } if (registry == null) { throw new ArgumentNullException(nameof(registry)); } var duneLocationCalculationEntity = new DuneLocationCalculationEntity { DuneLocationEntity = registry.Get(calculation.DuneLocation) }; CreateDuneLocationOutput(duneLocationCalculationEntity, calculation.Output); return(duneLocationCalculationEntity); }