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