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