public void Create_WithNaNParameters_ReturnsDuneLocationCalculationOutputEntityWithNullValues()
{
// Setup
var random = new Random(21);
var output = new DuneLocationCalculationOutput(random.NextEnumValue <CalculationConvergence>(), new DuneLocationCalculationOutput.ConstructionProperties
{
WaterLevel = double.NaN,
WaveHeight = double.NaN,
WavePeriod = double.NaN,
TargetProbability = double.NaN,
TargetReliability = double.NaN,
CalculatedProbability = double.NaN,
CalculatedReliability = double.NaN
});
// Call
DuneLocationCalculationOutputEntity entity = output.Create();
// Assert
Assert.IsNotNull(entity);
Assert.IsNull(entity.WaterLevel);
Assert.IsNull(entity.WaveHeight);
Assert.IsNull(entity.WavePeriod);
Assert.IsNull(entity.TargetProbability);
Assert.IsNull(entity.TargetReliability);
Assert.IsNull(entity.CalculatedProbability);
Assert.IsNull(entity.CalculatedReliability);
Assert.AreEqual(Convert.ToByte(output.CalculationConvergence), entity.CalculationConvergence);
}
public void Read_NullParameters_ReturnsDuneLocationOutputWithNaN()
{
// Setup
var convergence = new Random(36).NextEnumValue <CalculationConvergence>();
var entity = new DuneLocationCalculationOutputEntity
{
WaterLevel = null,
WaveHeight = null,
WavePeriod = null,
TargetProbability = null,
TargetReliability = null,
CalculatedProbability = null,
CalculatedReliability = null,
CalculationConvergence = Convert.ToByte(convergence)
};
// Call
DuneLocationCalculationOutput output = entity.Read();
// Assert
Assert.IsNaN(output.WaterLevel);
Assert.IsNaN(output.WaveHeight);
Assert.IsNaN(output.WavePeriod);
Assert.IsNaN(output.TargetProbability);
Assert.IsNaN(output.TargetReliability);
Assert.IsNaN(output.CalculatedProbability);
Assert.IsNaN(output.CalculatedReliability);
Assert.AreEqual(convergence, output.CalculationConvergence);
}
public void Create_WithValidParameters_ReturnsDuneLocationCalculationOutputEntity()
{
// 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(),
TargetProbability = random.NextDouble(),
TargetReliability = random.NextDouble(),
CalculatedProbability = random.NextDouble(),
CalculatedReliability = random.NextDouble()
});
// Call
DuneLocationCalculationOutputEntity entity = output.Create();
// Assert
Assert.IsNotNull(entity);
Assert.AreEqual(output.WaterLevel, entity.WaterLevel, output.WaterLevel.GetAccuracy());
Assert.AreEqual(output.WaveHeight, entity.WaveHeight, output.WaveHeight.GetAccuracy());
Assert.AreEqual(output.WavePeriod, entity.WavePeriod, output.WavePeriod.GetAccuracy());
Assert.AreEqual(output.TargetProbability, entity.TargetProbability);
Assert.AreEqual(output.TargetReliability, entity.TargetReliability, output.TargetReliability.GetAccuracy());
Assert.AreEqual(output.CalculatedProbability, entity.CalculatedProbability);
Assert.AreEqual(output.CalculatedReliability, entity.CalculatedReliability, output.CalculatedReliability.GetAccuracy());
Assert.AreEqual(Convert.ToByte(output.CalculationConvergence), entity.CalculationConvergence);
}
private static void CreateDuneLocationOutput(DuneLocationCalculationEntity calculationEntity,
DuneLocationCalculationOutput output)
{
if (output != null)
{
calculationEntity.DuneLocationCalculationOutputEntities.Add(output.Create());
}
}
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 Constructor_EmptyConstructionProperties_DefaultValues()
{
// Call
var output = new DuneLocationCalculationOutput(CalculationConvergence.CalculatedConverged,
new DuneLocationCalculationOutput.ConstructionProperties());
// Assert
Assert.IsNaN(output.WaterLevel);
Assert.IsNaN(output.WaveHeight);
Assert.IsNaN(output.WavePeriod);
Assert.IsNaN(output.CalculatedProbability);
Assert.IsNaN(output.TargetProbability);
Assert.IsNaN(output.CalculatedReliability);
Assert.IsNaN(output.CalculatedProbability);
}
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();
}
private static IEnumerable <string> GetOutputValues(DuneLocationCalculationOutput calculationOutput)
{
return(calculationOutput == null
? new[]
{
Resources.DuneLocationCalculationsWriter_CreateCsvLine_Parameter_without_value,
Resources.DuneLocationCalculationsWriter_CreateCsvLine_Parameter_without_value,
Resources.DuneLocationCalculationsWriter_CreateCsvLine_Parameter_without_value
}
: new[]
{
GetOutputValue(calculationOutput.WaterLevel),
GetOutputValue(calculationOutput.WaveHeight),
GetOutputValue(calculationOutput.WavePeriod)
});
}
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);
}
/// <summary>
/// Creates a <see cref="DuneLocationCalculationOutputEntity"/> based on the
/// information of the <see cref="DuneLocationCalculationOutput"/>.
/// </summary>
/// <param name="output">The output to create a database entity for.</param>
/// <returns>A new <see cref="DuneLocationCalculationOutputEntity"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="output"/> is <c>null</c>.</exception>
internal static DuneLocationCalculationOutputEntity Create(this DuneLocationCalculationOutput output)
{
if (output == null)
{
throw new ArgumentNullException(nameof(output));
}
return(new DuneLocationCalculationOutputEntity
{
WaterLevel = output.WaterLevel.ToNaNAsNull(),
WaveHeight = output.WaveHeight.ToNaNAsNull(),
WavePeriod = output.WavePeriod.ToNaNAsNull(),
TargetProbability = output.TargetProbability.ToNaNAsNull(),
TargetReliability = output.TargetReliability.ToNaNAsNull(),
CalculatedProbability = output.CalculatedProbability.ToNaNAsNull(),
CalculatedReliability = output.CalculatedReliability.ToNaNAsNull(),
CalculationConvergence = Convert.ToByte(output.CalculationConvergence)
});
}
public void Constructor_ValidInput_ExpectedProperties(double targetProbability, double calculatedProbability)
{
// Setup
var random = new Random(32);
double waterLevel = random.NextDouble();
double waveHeight = random.NextDouble();
double wavePeriod = random.NextDouble();
double targetReliability = random.NextDouble();
double calculatedReliability = random.NextDouble();
var convergence = random.NextEnumValue <CalculationConvergence>();
// Call
var output = new DuneLocationCalculationOutput(convergence,
new DuneLocationCalculationOutput.ConstructionProperties
{
WaterLevel = waterLevel,
WaveHeight = waveHeight,
WavePeriod = wavePeriod,
TargetProbability = targetProbability,
TargetReliability = targetReliability,
CalculatedProbability = calculatedProbability,
CalculatedReliability = calculatedReliability
});
// Assert
Assert.AreEqual(2, output.WaterLevel.NumberOfDecimalPlaces);
Assert.AreEqual(waterLevel, output.WaterLevel, output.WaterLevel.GetAccuracy());
Assert.AreEqual(2, output.WaveHeight.NumberOfDecimalPlaces);
Assert.AreEqual(waveHeight, output.WaveHeight, output.WaveHeight.GetAccuracy());
Assert.AreEqual(2, output.WavePeriod.NumberOfDecimalPlaces);
Assert.AreEqual(wavePeriod, output.WavePeriod, output.WavePeriod.GetAccuracy());
Assert.AreEqual(targetProbability, output.TargetProbability);
Assert.AreEqual(5, output.TargetReliability.NumberOfDecimalPlaces);
Assert.AreEqual(targetReliability, output.TargetReliability, output.TargetReliability.GetAccuracy());
Assert.AreEqual(calculatedProbability, output.CalculatedProbability);
Assert.AreEqual(5, output.CalculatedReliability.NumberOfDecimalPlaces);
Assert.AreEqual(calculatedReliability, output.CalculatedReliability, output.CalculatedReliability.GetAccuracy());
Assert.AreEqual(convergence, output.CalculationConvergence);
}
public void Read_ValidParameters_ReturnsDuneLocationOutput()
{
// Setup
var random = new Random(22);
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 DuneLocationCalculationOutputEntity
{
WaterLevel = waterLevel,
WaveHeight = waveHeight,
WavePeriod = wavePeriod,
TargetProbability = targetProbability,
TargetReliability = targetReliability,
CalculatedProbability = calculatedProbability,
CalculatedReliability = calculatedReliability,
CalculationConvergence = Convert.ToByte(convergence)
};
// Call
DuneLocationCalculationOutput output = entity.Read();
// Assert
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 CreateAggregatedDuneLocations_WithAllData_ReturnAggregatedDuneLocations()
{
// Setup
var random = new Random(21);
var duneLocations = new[]
{
new DuneLocation(1, "location1", new Point2D(1, 1), new DuneLocation.ConstructionProperties()),
new DuneLocation(2, "location2", new Point2D(2, 2), new DuneLocation.ConstructionProperties())
};
var targetProbabilities = new[]
{
new DuneLocationCalculationsForTargetProbability(0.1)
{
DuneLocationCalculations =
{
new DuneLocationCalculation(duneLocations[0])
{
Output = new TestDuneLocationCalculationOutput(random.NextDouble(), random.NextDouble(), random.NextDouble())
},
new DuneLocationCalculation(duneLocations[1])
{
Output = new TestDuneLocationCalculationOutput(random.NextDouble(), random.NextDouble(), random.NextDouble())
}
}
},
new DuneLocationCalculationsForTargetProbability(0.001)
{
DuneLocationCalculations =
{
new DuneLocationCalculation(duneLocations[0])
{
Output = new TestDuneLocationCalculationOutput(random.NextDouble(), random.NextDouble(), random.NextDouble())
},
new DuneLocationCalculation(duneLocations[1])
}
}
};
// Call
IEnumerable <AggregatedDuneLocation> aggregatedLocations = AggregatedDuneLocationFactory.CreateAggregatedDuneLocations(duneLocations, targetProbabilities);
// Assert
Assert.AreEqual(duneLocations.Length, aggregatedLocations.Count());
for (var i = 0; i < duneLocations.Length; i++)
{
DuneLocation duneLocation = duneLocations[i];
AggregatedDuneLocation aggregatedLocation = aggregatedLocations.ElementAt(i);
Assert.AreEqual(duneLocation.Id, aggregatedLocation.Id);
Assert.AreEqual(duneLocation.Name, aggregatedLocation.Name);
Assert.AreEqual(duneLocation.Location, aggregatedLocation.Location);
Assert.AreEqual(duneLocation.CoastalAreaId, aggregatedLocation.CoastalAreaId);
Assert.AreEqual(duneLocation.Offset, aggregatedLocation.Offset);
Assert.AreEqual(duneLocation.D50, aggregatedLocation.D50);
for (var j = 0; j < targetProbabilities.Length; j++)
{
Assert.AreEqual(targetProbabilities[j].TargetProbability, aggregatedLocation.WaterLevelCalculationsForTargetProbabilities.ElementAt(j).Item1);
Assert.AreEqual(targetProbabilities[j].TargetProbability, aggregatedLocation.WaveHeightCalculationsForTargetProbabilities.ElementAt(j).Item1);
Assert.AreEqual(targetProbabilities[j].TargetProbability, aggregatedLocation.WavePeriodCalculationsForTargetProbabilities.ElementAt(j).Item1);
DuneLocationCalculationOutput output = GetOutput(targetProbabilities[j].DuneLocationCalculations, duneLocations[i]);
Assert.AreEqual(output?.WaterLevel ?? RoundedDouble.NaN, aggregatedLocation.WaterLevelCalculationsForTargetProbabilities.ElementAt(j).Item2);
Assert.AreEqual(output?.WaveHeight ?? RoundedDouble.NaN, aggregatedLocation.WaveHeightCalculationsForTargetProbabilities.ElementAt(j).Item2);
Assert.AreEqual(output?.WavePeriod ?? RoundedDouble.NaN, aggregatedLocation.WavePeriodCalculationsForTargetProbabilities.ElementAt(j).Item2);
}
}
}
public void Calculate_CalculationRan_SetOutput()
{
// Setup
const double targetProbability = 1.0 / 30;
var calculator = new TestDunesBoundaryConditionsCalculator
{
ReliabilityIndex = 3.27052,
WaterLevel = 4.82912,
WaveHeight = 2.88936,
WavePeriod = 10.65437,
Converged = true
};
var mockRepository = new MockRepository();
var calculatorFactory = mockRepository.StrictMock <IHydraRingCalculatorFactory>();
calculatorFactory.Expect(cf => cf.CreateDunesBoundaryConditionsCalculator(null))
.IgnoreArguments()
.Return(calculator);
var calculationMessageProvider = mockRepository.StrictMock <ICalculationMessageProvider>();
mockRepository.ReplayAll();
var duneLocationCalculation = new DuneLocationCalculation(new TestDuneLocation());
// Precondition
Assert.IsNull(duneLocationCalculation.Output);
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(3, msgs.Length);
CalculationServiceTestHelper.AssertCalculationStartMessage(msgs[0]);
StringAssert.StartsWith("Hydraulische belastingenberekening is uitgevoerd op de tijdelijke locatie", msgs[1]);
CalculationServiceTestHelper.AssertCalculationEndMessage(msgs[2]);
});
double targetReliability = StatisticsConverter.ProbabilityToReliability(targetProbability);
double calculatedProbability = StatisticsConverter.ReliabilityToProbability(calculator.ReliabilityIndex);
DuneLocationCalculationOutput actualCalculationOutput = duneLocationCalculation.Output;
Assert.IsNotNull(actualCalculationOutput);
Assert.AreEqual(calculator.ReliabilityIndex, actualCalculationOutput.CalculatedReliability.Value);
Assert.AreEqual(calculatedProbability, actualCalculationOutput.CalculatedProbability);
Assert.AreEqual(targetProbability, actualCalculationOutput.TargetProbability);
Assert.AreEqual(targetReliability, actualCalculationOutput.TargetReliability, actualCalculationOutput.TargetReliability.GetAccuracy());
Assert.AreEqual(calculator.WaterLevel, actualCalculationOutput.WaterLevel, actualCalculationOutput.WaterLevel.GetAccuracy());
Assert.AreEqual(calculator.WaveHeight, actualCalculationOutput.WaveHeight, actualCalculationOutput.WaveHeight.GetAccuracy());
Assert.AreEqual(calculator.WavePeriod, actualCalculationOutput.WavePeriod, actualCalculationOutput.WavePeriod.GetAccuracy());
}
mockRepository.VerifyAll();
}
public void GetProperties_ValidDesignWaterLevel_ReturnsExpectedValues()
{
// Setup
const long id = 1234L;
const double x = 567.0;
const double y = 890.0;
const string name = "<some name>";
var random = new Random();
int coastalAreaId = random.Next();
var convergence = random.NextEnumValue <CalculationConvergence>();
double offset = random.NextDouble();
double orientation = random.NextDouble();
double d50 = random.NextDouble();
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 output = new DuneLocationCalculationOutput(
convergence,
new DuneLocationCalculationOutput.ConstructionProperties
{
WaterLevel = waterLevel,
WaveHeight = waveHeight,
WavePeriod = wavePeriod,
TargetProbability = targetProbability,
TargetReliability = targetReliability,
CalculatedProbability = calculatedProbability,
CalculatedReliability = calculatedReliability
});
var duneLocation = new DuneLocation(id, name, new Point2D(x, y),
new DuneLocation.ConstructionProperties
{
CoastalAreaId = coastalAreaId,
Offset = offset,
Orientation = orientation,
D50 = d50
});
var duneLocationCalculation = new DuneLocationCalculation(duneLocation)
{
Output = output
};
// Call
var properties = new DuneLocationCalculationProperties(duneLocationCalculation);
// Assert
Assert.AreEqual(id, properties.Id);
Assert.AreEqual(name, properties.Name);
Assert.AreEqual(coastalAreaId, properties.CoastalAreaId);
Assert.AreEqual(duneLocation.Offset.ToString("0.#", CultureInfo.InvariantCulture), properties.Offset);
var expectedLocation = new Point2D(x, y);
Assert.AreEqual(expectedLocation, properties.Location);
Assert.AreEqual(waterLevel, properties.WaterLevel, properties.WaterLevel.GetAccuracy());
Assert.AreEqual(waveHeight, properties.WaveHeight, properties.WaveHeight.GetAccuracy());
Assert.AreEqual(wavePeriod, properties.WavePeriod, properties.WavePeriod.GetAccuracy());
Assert.AreEqual(d50, properties.D50, properties.D50.GetAccuracy());
Assert.AreEqual(targetProbability, properties.TargetProbability);
Assert.AreEqual(targetReliability, properties.TargetReliability, properties.TargetReliability.GetAccuracy());
Assert.AreEqual(calculatedProbability, properties.CalculatedProbability, properties.CalculatedProbability);
Assert.AreEqual(calculatedReliability, properties.CalculatedReliability, properties.CalculatedReliability.GetAccuracy());
string convergenceValue = EnumDisplayNameHelper.GetDisplayName(convergence);
Assert.AreEqual(convergenceValue, properties.Convergence);
}
