/// <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)); }
public void Validate_WithArgumentAndKernelValidationErrorOccurs_ReturnsErrorMessages(KernelValidationError error, string expectedMessage) { // 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(error); var testFactory = new TestKernelFactory(kernel); using (new BalancedFieldLengthKernelFactoryConfig(testFactory)) { var module = new BalancedFieldLengthCalculationModule(); // Call IEnumerable <string> messages = module.Validate(calculation); // Assert CollectionAssert.AreEqual(new[] { expectedMessage }, messages); } }
public void Validate_InvalidEndFailureSpeed_ReturnsValidationMessage(int invalidEndFailureSpeed) { // Setup var calculation = new BalancedFieldLengthCalculation(); SetValidAircraftData(calculation.AircraftData); SetEngineData(calculation.EngineData); SetSimulationSettingsData(calculation.SimulationSettings); calculation.SimulationSettings.EndFailureVelocity = invalidEndFailureSpeed; 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 IEnumerable <string> messages = module.Validate(calculation); // Assert CollectionAssert.AreEqual(new[] { "End failure velocity must be larger than 0." }, messages); } }
public void Validate_WithArgumentAndNoErrorOccurs_ReturnsNoErrorMessages() { // Setup var random = new Random(21); int nrOfFailedEngines = random.Next(); var calculation = new BalancedFieldLengthCalculation(); SetValidAircraftData(calculation.AircraftData); SetEngineData(calculation.EngineData); SetSimulationSettingsData(calculation.SimulationSettings); calculation.EngineData.NrOfFailedEngines = nrOfFailedEngines; 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 IEnumerable <string> messages = module.Validate(calculation); // Assert CollectionAssert.IsEmpty(messages); } }
public void GivenInvalidAircraftDataCausingException_WhenCallingValidate_ReturnsErrorMessages() { // Setup var calculation = new BalancedFieldLengthCalculation(); SetValidAircraftData(calculation.AircraftData); SetEngineData(calculation.EngineData); calculation.AircraftData.AspectRatio = double.NaN; var kernel = Substitute.For <IAggregatedDistanceCalculatorKernel>(); var testFactory = new TestKernelFactory(kernel); using (new BalancedFieldLengthKernelFactoryConfig(testFactory)) { var module = new BalancedFieldLengthCalculationModule(); // Call IEnumerable <string> messages = module.Validate(calculation); // Assert CollectionAssert.AreEqual(new[] { "aspectRatio must be a concrete number and cannot be NaN or Infinity." }, messages); } }
public void Calculate_WithValidArgumentsAndResult_ReturnsExpectedOutput() { // Setup var random = new Random(21); int nrOfFailedEngines = random.Next(); double density = random.NextDouble(); double gravitationalAcceleration = random.NextDouble(); var calculation = new BalancedFieldLengthCalculation(); SetValidAircraftData(calculation.AircraftData); SetEngineData(calculation.EngineData); SetSimulationSettingsData(calculation.SimulationSettings); calculation.SimulationSettings.Density = density; calculation.SimulationSettings.GravitationalAcceleration = gravitationalAcceleration; calculation.SimulationSettings.EndFailureVelocity = 3; calculation.EngineData.NrOfFailedEngines = nrOfFailedEngines; const double expectedVelocity = 11; const double expectedDistance = 20; var outputs = new[] { new AggregatedDistanceOutput(10, 10, 30), new AggregatedDistanceOutput(expectedVelocity, expectedDistance, 20), new AggregatedDistanceOutput(12, 30, 10) }; var kernel = Substitute.For <IAggregatedDistanceCalculatorKernel>(); kernel.Calculate(Arg.Any <KernelAircraftData>(), Arg.Any <EulerIntegrator>(), Arg.Any <int>(), Arg.Any <double>(), Arg.Any <double>(), Arg.Any <CalculationSettings>()) .Returns(outputs[0], outputs[1], outputs[2]); var testFactory = new TestKernelFactory(kernel); using (new BalancedFieldLengthKernelFactoryConfig(testFactory)) { var module = new BalancedFieldLengthCalculationModule(); // Call BalancedFieldLengthOutput output = module.Calculate(calculation); // Assert Assert.That(output.Velocity, Is.EqualTo(expectedVelocity)); Assert.That(output.Distance, Is.EqualTo(expectedDistance)); ICall[] calls = kernel.ReceivedCalls().ToArray(); Assert.That(calls.Length, Is.EqualTo(3)); AssertCalculateCall(calls[0], calculation, 0); AssertCalculateCall(calls[1], calculation, 1); AssertCalculateCall(calls[2], calculation, 2); } }
public IEnumerable <string> Validate(BalancedFieldLengthCalculation calculation) { if (ThrowCreateKernelDataException) { throw new CreateKernelDataException("Exception"); } InputCalculation = calculation; return(ValidationMessages); }
public void Constructor_ExpectedValues() { // Call var calculation = new BalancedFieldLengthCalculation(); // Assert Assert.That(calculation.AircraftData, Is.Not.Null); Assert.That(calculation.EngineData, Is.Not.Null); Assert.That(calculation.SimulationSettings, Is.Not.Null); Assert.That(calculation.Output, Is.Null); }
/// <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 }); } }
public BalancedFieldLengthOutput Calculate(BalancedFieldLengthCalculation calculation) { if (ThrowCreateKernelDataException) { throw new CreateKernelDataException("Exception"); } if (ThrowKernelCalculationException) { throw new KernelCalculationException("Exception"); } InputCalculation = calculation; return(Output); }
public void Validate_WithConfiguredCalculationModule_ExpectedValues() { // Given IEnumerable <string> messages = Enumerable.Empty <string>(); var calculationModule = new TestBalancedFieldLengthCalculationModule { ValidationMessages = messages }; var calculation = new BalancedFieldLengthCalculation(); // When IEnumerable <string> actualMessages = calculationModule.Validate(calculation); // Then Assert.That(actualMessages, Is.SameAs(messages)); Assert.That(calculationModule.InputCalculation, Is.SameAs(calculation)); }
public void Calculate_WithConfiguredCalculationModule_ExpectedValues() { // Given var random = new Random(21); var output = new BalancedFieldLengthOutput(random.NextDouble(), random.NextDouble()); var calculationModule = new TestBalancedFieldLengthCalculationModule { Output = output }; var calculation = new BalancedFieldLengthCalculation(); // When BalancedFieldLengthOutput actualOutput = calculationModule.Calculate(calculation); // Then Assert.That(actualOutput, Is.SameAs(output)); Assert.That(calculationModule.InputCalculation, Is.SameAs(calculation)); }
/// <summary> /// Creates a new instance of <see cref="MainViewModel"/>. /// </summary> public MainViewModel() { calculation = new BalancedFieldLengthCalculation(); #if DEBUG ConfigureSimulationSettings(calculation.SimulationSettings); ConfigureAircraftData(calculation.AircraftData); ConfigureEngineData(calculation.EngineData); #endif InitializeValidationRuleProviders(); TabControlViewModel tabControlViewModel = CreateTabControlViewModel(); TabControlViewModel = tabControlViewModel; MessageWindowViewModel = new MessageWindowViewModel(); OutputViewModel = null; CalculateCommand = new RelayCommand(Calculate); }
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 GivenViewModel_WhenCalculationPressed_ThenInputArgumentSent() { // Given var random = new Random(21); var viewModel = new MainViewModel(); TabControlViewModel tabControlViewModel = viewModel.TabControlViewModel; ObservableCollection <ITabViewModel> tabs = tabControlViewModel.Tabs; // Precondition Assert.That(tabs, Has.Count.EqualTo(3)); Assert.That(tabs[0], Is.TypeOf <GeneralSimulationSettingsTabViewModel>()); Assert.That(tabs[1], Is.TypeOf <EngineSettingsTabViewModel>()); Assert.That(tabs[2], Is.TypeOf <AircraftDataTabViewModel>()); var generalSimulationSettingsViewModel = (GeneralSimulationSettingsTabViewModel)tabs[0]; var engineSettingsViewModel = (EngineSettingsTabViewModel)tabs[1]; var aircraftDataViewModel = (AircraftDataTabViewModel)tabs[2]; SetGeneralSettings(generalSimulationSettingsViewModel, random.Next()); SetEngineData(engineSettingsViewModel, random.Next()); SetAircraftData(aircraftDataViewModel, random.Next()); using (new BalancedFieldLengthCalculationModuleFactoryConfig()) { var instance = (TestBalancedFieldLengthCalculationModuleFactory) BalancedFieldLengthCalculationModuleFactory.Instance; TestBalancedFieldLengthCalculationModule testModule = instance.TestModule; testModule.Output = new BalancedFieldLengthOutput(random.NextDouble(), random.NextDouble()); // When viewModel.CalculateCommand.Execute(null); // Then BalancedFieldLengthCalculation calculationInput = testModule.InputCalculation; AssertGeneralSettings(generalSimulationSettingsViewModel, calculationInput.SimulationSettings); AssertEngineData(engineSettingsViewModel, calculationInput.EngineData); AssertAircraftData(aircraftDataViewModel, calculationInput.AircraftData); } }
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)); } }
public void Calculate_CalculatorThrowsCalculateException_ThrowsKernelCalculateException() { // Setup var calculation = new BalancedFieldLengthCalculation(); SetValidAircraftData(calculation.AircraftData); SetEngineData(calculation.EngineData); SetSimulationSettingsData(calculation.SimulationSettings); calculation.SimulationSettings.EndFailureVelocity = 1; var kernel = Substitute.For <IAggregatedDistanceCalculatorKernel>(); var calculatorException = new CalculatorException("Can't calculate this."); kernel.Calculate(Arg.Any <KernelAircraftData>(), Arg.Any <EulerIntegrator>(), Arg.Any <int>(), Arg.Any <double>(), Arg.Any <double>(), Arg.Any <CalculationSettings>()) .ThrowsForAnyArgs(calculatorException); var testFactory = new TestKernelFactory(kernel); using (new BalancedFieldLengthKernelFactoryConfig(testFactory)) { var module = new BalancedFieldLengthCalculationModule(); // Call TestDelegate call = () => module.Calculate(calculation); // Assert var exception = Assert.Throws <KernelCalculationException>(call); Assert.That(exception.InnerException, Is.SameAs(calculatorException)); Assert.That(exception.Message, Is.EqualTo(calculatorException.Message)); } }