public void TimeStep_ValueChanges_RaisesNotifyPropertyChangedEvent()
{
// Setup
var settings = new GeneralSimulationSettingsData();
var viewModel = new GeneralSimulationSettingsTabViewModel(settings);
bool propertyChangedTriggered = false;
PropertyChangedEventArgs eventArgs = null;
viewModel.PropertyChanged += (o, e) =>
{
propertyChangedTriggered = true;
eventArgs = e;
};
var random = new Random(21);
double newValue = random.NextDouble();
// Call
viewModel.TimeStep = newValue;
// Assert
Assert.That(propertyChangedTriggered, Is.True);
Assert.That(eventArgs, Is.Not.Null);
Assert.That(eventArgs.PropertyName, Is.EqualTo(nameof(GeneralSimulationSettingsTabViewModel.TimeStep)));
Assert.That(settings.TimeStep, Is.EqualTo(newValue));
}
/// <summary>
/// Calculates the <see cref="BalancedFieldLengthOutput"/> based on <paramref name="calculation"/>.
/// </summary>
/// <param name="calculation">The <see cref="BalancedFieldLengthCalculation"/> to calculate for.</param>
/// <returns>A <see cref="BalancedFieldLengthOutput"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="calculation"/> is <c>null</c>.</exception>
/// <exception cref="CreateKernelDataException">Thrown when the calculation input
/// could not be created for the kernel.</exception>
/// <exception cref="KernelCalculationException">Thrown when <see cref="AggregatedDistanceOutput"/>
/// could not be calculated.</exception>
public BalancedFieldLengthOutput Calculate(BalancedFieldLengthCalculation calculation)
{
if (calculation == null)
{
throw new ArgumentNullException(nameof(calculation));
}
GeneralSimulationSettingsData generalSimulationSettings = calculation.SimulationSettings;
double density = generalSimulationSettings.Density;
int endVelocity = generalSimulationSettings.EndFailureVelocity;
double gravitationalAcceleration = generalSimulationSettings.GravitationalAcceleration;
EngineData engineData = calculation.EngineData;
int nrOfFailedEngines = engineData.NrOfFailedEngines;
AircraftData aircraftData = AircraftDataFactory.Create(calculation.AircraftData, engineData);
var integrator = new EulerIntegrator();
var outputs = new List <AggregatedDistanceOutput>();
for (int i = 0; i < endVelocity; i++)
{
var calculationInput = new CalculationInput(generalSimulationSettings,
i,
aircraftData,
integrator,
nrOfFailedEngines,
density,
gravitationalAcceleration);
AggregatedDistanceOutput output = CalculateDistances(calculationInput);
outputs.Add(output);
}
return(BalancedFieldLengthOutputFactory.Create(outputs));
}
/// <summary>
/// Asserts whether the <paramref name="calculationSettings"/> contain the correct information based on
/// <paramref name="simulationSettings"/>.
/// </summary>
/// <param name="simulationSettings">The <see cref="GeneralSimulationSettingsData"/> to use as a reference.</param>
/// <param name="failureSpeed">The failure speed to use as reference.</param>
/// <param name="calculationSettings">The <see cref="CalculationSettings"/> to assert.</param>
public static void AssertCalculationSettings(GeneralSimulationSettingsData simulationSettings,
int failureSpeed,
CalculationSettings calculationSettings)
{
Assert.That(calculationSettings.TimeStep, Is.EqualTo(simulationSettings.TimeStep));
Assert.That(calculationSettings.MaximumNrOfTimeSteps, Is.EqualTo(simulationSettings.MaximumNrOfIterations));
Assert.That(calculationSettings.FailureSpeed, Is.EqualTo(failureSpeed));
}
private static void ConfigureSimulationSettings(GeneralSimulationSettingsData simulationSettings)
{
simulationSettings.Density = 1.225;
simulationSettings.GravitationalAcceleration = 9.81;
simulationSettings.MaximumNrOfIterations = 10000;
simulationSettings.EndFailureVelocity = 90;
simulationSettings.TimeStep = 0.1;
}
private static void AssertGeneralSettings(GeneralSimulationSettingsTabViewModel expected,
GeneralSimulationSettingsData actual)
{
Assert.That(actual.MaximumNrOfIterations, Is.EqualTo(expected.MaximumNrOfIterations));
Assert.That(actual.TimeStep, Is.EqualTo(expected.TimeStep));
Assert.That(actual.EndFailureVelocity, Is.EqualTo(expected.EndFailureVelocity));
Assert.That(actual.GravitationalAcceleration, Is.EqualTo(expected.GravitationalAcceleration));
Assert.That(actual.Density, Is.EqualTo(expected.Density));
}
/// <summary>
/// Creates an instance of <see cref="EngineDataRuleProvider"/>.
/// </summary>
/// <param name="data">The <see cref="GeneralSimulationSettingsData"/> to create the provider for.</param>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="data"/> is <c>null</c>.</exception>
public GeneralSimulationSettingsDataRuleProvider(GeneralSimulationSettingsData data)
{
if (data == null)
{
throw new ArgumentNullException(nameof(data));
}
this.data = data;
}
private static void SetSimulationSettingsData(GeneralSimulationSettingsData data)
{
var random = new Random(21);
data.TimeStep = random.NextDouble();
data.MaximumNrOfIterations = random.Next();
data.Density = random.NextDouble();
data.GravitationalAcceleration = random.NextDouble();
data.EndFailureVelocity = random.Next();
}
public void Constructor_WithArguments_ExpectedValues()
{
// Setup
var data = new GeneralSimulationSettingsData();
// Call
var provider = new GeneralSimulationSettingsDataRuleProvider(data);
// Assert
Assert.That(provider, Is.InstanceOf <IDataModelRuleProvider>());
}
public void Constructor_ExpectedValues()
{
// Call
var generalSimulationSettings = new GeneralSimulationSettingsData();
// Assert
Assert.That(generalSimulationSettings.Density, Is.EqualTo(1.225));
Assert.That(generalSimulationSettings.GravitationalAcceleration, Is.EqualTo(9.81));
Assert.That(generalSimulationSettings.EndFailureVelocity, Is.Zero);
Assert.That(generalSimulationSettings.MaximumNrOfIterations, Is.Zero);
Assert.That(generalSimulationSettings.TimeStep, Is.NaN);
}
/// <summary>
/// Validates a <see cref="BalancedFieldLengthCalculation"/>.
/// </summary>
/// <param name="calculation">The calculation to validate.</param>
/// <returns>A collection of validation messages if the validation failed, empty otherwise.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="calculation"/>
/// is <c>null</c>.</exception>
public IEnumerable <string> Validate(BalancedFieldLengthCalculation calculation)
{
if (calculation == null)
{
throw new ArgumentNullException(nameof(calculation));
}
try
{
EngineData engineData = calculation.EngineData;
GeneralSimulationSettingsData generalSimulationSettings = calculation.SimulationSettings;
AircraftData aircraftData = AircraftDataFactory.Create(calculation.AircraftData, engineData);
KernelValidationError validationResult = kernel.Validate(aircraftData,
generalSimulationSettings.Density,
generalSimulationSettings.GravitationalAcceleration,
engineData.NrOfFailedEngines);
var messages = new List <string>();
if (generalSimulationSettings.EndFailureVelocity < 1)
{
messages.Add(Resources.BalancedFieldLengthCalculationModule_ValidationMessage_End_failure_velocity_must_be_larger_than_Zero);
}
if (validationResult.HasFlag(KernelValidationError.InvalidDensity))
{
messages.Add(Resources.BalancedFieldLengthCalculationModule_ValidationMessage_Invalid_Density);
}
if (validationResult.HasFlag(KernelValidationError.InvalidGravitationalAcceleration))
{
messages.Add(Resources.BalancedFieldLengthCalculationModule_ValidationMessage_Invalid_GravitationalAcceleration);
}
if (validationResult.HasFlag(KernelValidationError.InvalidNrOfFailedEngines))
{
messages.Add(Resources.BalancedFieldLengthCalculationModule_ValidationMessage_Invalid_NrOfFailedEngines);
}
return(messages);
}
catch (CreateKernelDataException e)
{
return(new[]
{
e.Message
});
}
}
/// <summary>
/// Creates a <see cref="CalculationSettings"/> based on <see cref="GeneralSimulationSettingsData"/>.
/// </summary>
/// <param name="settings">The <see cref="GeneralSimulationSettingsData"/> to create
/// a <see cref="CalculationSettings"/> for.</param>
/// <param name="failureSpeed">The failure speed to create the settings for. [m/s]</param>
/// <returns>A <see cref="CalculationSettings"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="settings"/>
/// is <c>null</c>.</exception>
/// <exception cref="CreateKernelDataException">Thrown when <see cref="CalculationSettings"/>
/// could not be successfully created.</exception>
public static CalculationSettings Create(GeneralSimulationSettingsData settings, int failureSpeed)
{
if (settings == null)
{
throw new ArgumentNullException(nameof(settings));
}
try
{
return(new CalculationSettings(failureSpeed, settings.MaximumNrOfIterations, settings.TimeStep));
}
catch (ArgumentException e)
{
throw new CreateKernelDataException(e.Message, e);
}
}
public CalculationInput(GeneralSimulationSettingsData generalSimulationSettings,
int failureVelocity,
AircraftData aircraftData,
IIntegrator integrator,
int nrOfFailedEngines,
double density,
double gravitationalAcceleration)
{
GeneralSimulationSettings = generalSimulationSettings;
FailureVelocity = failureVelocity;
AircraftData = aircraftData;
Integrator = integrator;
NrOfFailedEngines = nrOfFailedEngines;
Density = density;
GravitationalAcceleration = gravitationalAcceleration;
}
/// <summary>
/// Creates a new instance of <see cref="GeneralSimulationSettingsTabViewModel"/>.
/// </summary>
/// <param name="settings">The <see cref="GeneralSimulationSettingsData"/> to create the viewmodel for.</param>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="settings"/> is <c>null</c>.</exception>
public GeneralSimulationSettingsTabViewModel(GeneralSimulationSettingsData settings)
{
if (settings == null)
{
throw new ArgumentNullException(nameof(settings));
}
this.settings = settings;
maximumNrOfIterations = settings.MaximumNrOfIterations;
endFailureVelocity = settings.EndFailureVelocity;
timeStep = settings.TimeStep;
gravitationalAcceleration = settings.GravitationalAcceleration;
density = settings.Density;
}
public void Create_WithValidGeneralSimulationSettingsData_ReturnsExpectedCalculationSettings()
{
// Setup
var random = new Random(21);
int failureSpeed = random.Next();
var settings = new GeneralSimulationSettingsData
{
TimeStep = random.NextDouble(),
MaximumNrOfIterations = random.Next()
};
// Call
CalculationSettings calculationSettings = CalculationSettingsFactory.Create(settings, failureSpeed);
// Assert
CalculationSettingsTestHelper.AssertCalculationSettings(settings, failureSpeed, calculationSettings);
}
public static void Constructor_ExpectedValues()
{
// Setup
var settings = new GeneralSimulationSettingsData();
// Call
var viewModel = new GeneralSimulationSettingsTabViewModel(settings);
// Assert
Assert.That(viewModel, Is.InstanceOf <ITabViewModel>());
Assert.That(viewModel, Is.InstanceOf <ViewModelBase>());
Assert.That(viewModel.TabName, Is.EqualTo("Simulation Settings"));
Assert.That(viewModel.MaximumNrOfIterations, Is.EqualTo(settings.MaximumNrOfIterations));
Assert.That(viewModel.TimeStep, Is.EqualTo(settings.TimeStep));
Assert.That(viewModel.EndFailureVelocity, Is.EqualTo(settings.EndFailureVelocity));
Assert.That(viewModel.GravitationalAcceleration, Is.EqualTo(settings.GravitationalAcceleration));
Assert.That(viewModel.Density, Is.EqualTo(settings.Density));
}
private static void AssertCalculateCall(ICall call,
BalancedFieldLengthCalculation calculation,
int failureVelocity)
{
object[] arguments = call.GetArguments();
AircraftDataTestHelper.AssertAircraftData(calculation.AircraftData,
calculation.EngineData,
(KernelAircraftData)arguments[0]);
Assert.That(arguments[1], Is.TypeOf <EulerIntegrator>());
GeneralSimulationSettingsData simulationSettings = calculation.SimulationSettings;
Assert.That(arguments[2], Is.EqualTo(calculation.EngineData.NrOfFailedEngines));
Assert.That(arguments[3], Is.EqualTo(simulationSettings.Density));
Assert.That(arguments[4], Is.EqualTo(simulationSettings.GravitationalAcceleration));
CalculationSettingsTestHelper.AssertCalculationSettings(simulationSettings, failureVelocity,
(CalculationSettings)arguments[5]);
}
public void Create_WithGeneralSimulationSettingsDataResultingInArgumentOutOfRangeException_ThrowsKernelDataCreateException()
{
// Setup
var random = new Random(21);
var settings = new GeneralSimulationSettingsData
{
TimeStep = random.NextDouble(),
MaximumNrOfIterations = -1 * random.Next()
};
// Call
TestDelegate call = () => CalculationSettingsFactory.Create(settings, random.Next());
// Assert
var exception = Assert.Throws <CreateKernelDataException>(call);
Exception innerException = exception.InnerException;
Assert.That(innerException, Is.TypeOf <ArgumentOutOfRangeException>());
Assert.That(exception.Message, Is.EqualTo(innerException.Message));
}
public void GetDataModelValidationRules_Always_ReturnsExpectedValidationRules()
{
// Setup
var data = new GeneralSimulationSettingsData();
var provider = new GeneralSimulationSettingsDataRuleProvider(data);
// Call
IDataModelValidationRule[] rules = provider.GetDataModelValidationRules().ToArray();
// Assert
Assert.That(rules, Has.Length.EqualTo(8));
Assert.That(rules[0], Is.TypeOf <DoubleParameterConcreteValueRule>());
Assert.That(rules[1], Is.TypeOf <ComparableParameterGreaterThanRule <double> >());
Assert.That(rules[2], Is.TypeOf <DoubleParameterConcreteValueRule>());
Assert.That(rules[3], Is.TypeOf <ComparableParameterGreaterThanRule <double> >());
Assert.That(rules[4], Is.TypeOf <DoubleParameterConcreteValueRule>());
Assert.That(rules[5], Is.TypeOf <ComparableParameterGreaterThanRule <double> >());
Assert.That(rules[6], Is.TypeOf <ComparableParameterGreaterThanRule <int> >());
Assert.That(rules[7], Is.TypeOf <ComparableParameterGreaterThanRule <int> >());
}
public void Validate_Always_FactoryReceiveCorrectData()
{
// Setup
var calculation = new BalancedFieldLengthCalculation();
SetValidAircraftData(calculation.AircraftData);
SetEngineData(calculation.EngineData);
SetSimulationSettingsData(calculation.SimulationSettings);
var kernel = Substitute.For <IAggregatedDistanceCalculatorKernel>();
kernel.Validate(Arg.Any <KernelAircraftData>(),
Arg.Any <double>(),
Arg.Any <double>(),
Arg.Any <int>())
.ReturnsForAnyArgs(KernelValidationError.None);
var testFactory = new TestKernelFactory(kernel);
using (new BalancedFieldLengthKernelFactoryConfig(testFactory))
{
var module = new BalancedFieldLengthCalculationModule();
// Call
module.Validate(calculation);
// Assert
ICall calls = kernel.ReceivedCalls().Single();
object[] arguments = calls.GetArguments();
AircraftDataTestHelper.AssertAircraftData(calculation.AircraftData,
calculation.EngineData,
(KernelAircraftData)arguments[0]);
GeneralSimulationSettingsData simulationSettings = calculation.SimulationSettings;
Assert.That(arguments[1], Is.EqualTo(simulationSettings.Density));
Assert.That(arguments[2], Is.EqualTo(simulationSettings.GravitationalAcceleration));
Assert.That(arguments[3], Is.EqualTo(calculation.EngineData.NrOfFailedEngines));
}
}
/// <summary>
/// Creates a new instance of <see cref="BalancedFieldLengthCalculation"/>.
/// </summary>
public BalancedFieldLengthCalculation()
{
SimulationSettings = new GeneralSimulationSettingsData();
AircraftData = new AircraftData();
EngineData = new EngineData();
}
