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