public void GivenViewModelAndCalculationSuccessful_WhenCalculating_ThenOutputGenerated()
{
// Given
var random = new Random(21);
var calculatedOutput = new BalancedFieldLengthOutput(random.NextDouble(), random.NextDouble());
var viewModel = new MainViewModel();
using (new BalancedFieldLengthCalculationModuleFactoryConfig())
{
var instance = (TestBalancedFieldLengthCalculationModuleFactory)
BalancedFieldLengthCalculationModuleFactory.Instance;
TestBalancedFieldLengthCalculationModule testModule = instance.TestModule;
testModule.Output = calculatedOutput;
// Precondition
MessageWindowViewModel messageWindowViewModel = viewModel.MessageWindowViewModel;
Assert.That(messageWindowViewModel.Messages, Is.Empty);
// When
viewModel.CalculateCommand.Execute(null);
// Then
OutputViewModel outputViewModel = viewModel.OutputViewModel;
Assert.That(outputViewModel, Is.Not.Null);
Assert.That(outputViewModel.BalancedFieldLengthDistance, Is.EqualTo(calculatedOutput.Distance));
Assert.That(outputViewModel.BalancedFieldLengthVelocity, Is.EqualTo(calculatedOutput.Velocity));
Assert.That(messageWindowViewModel.Messages, Has.Count.EqualTo(1));
MessageContext message = messageWindowViewModel.Messages.Single();
Assert.That(message.MessageType, Is.EqualTo(MessageType.Info));
Assert.That(message.Message, Is.EqualTo("Calculation completed."));
}
}
private void Calculate()
{
DataModelValidatorResult validationResult = GetValidationResult();
if (validationResult != DataModelValidatorResult.ValidResult)
{
LogValidationResultMessages(validationResult);
return;
}
try
{
IBalancedFieldLengthCalculationModuleFactory factory = BalancedFieldLengthCalculationModuleFactory.Instance;
IBalancedFieldLengthCalculationModule calculationModule = factory.CreateModule();
BalancedFieldLengthOutput output = calculationModule.Calculate(calculation);
OutputViewModel = new OutputViewModel(output);
MessageWindowViewModel.AddMessage(new MessageContext(MessageType.Info, Resources.MainViewModel_Calculate_Calculation_completed));
}
catch (Exception e) when(e is CreateKernelDataException || e is KernelCalculationException)
{
MessageWindowViewModel.AddMessage(new MessageContext(MessageType.Error, e.Message));
MessageWindowViewModel.AddMessage(new MessageContext(MessageType.Error, Resources.MainViewModel_Calculate_Calculation_failed));
}
}
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);
}
}
/// <summary>
/// Creates a new instance of <see cref="OutputViewModel"/>.
/// </summary>
/// <param name="output">The <see cref="BalancedFieldLengthOutput"/>
/// to create the view model for.</param>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="output"/>
/// is <c>null</c>.</exception>
public OutputViewModel(BalancedFieldLengthOutput output)
{
if (output == null)
{
throw new ArgumentNullException(nameof(output));
}
BalancedFieldLengthDistance = output.Distance;
BalancedFieldLengthVelocity = output.Velocity;
}
public void Constructor_WithArguments_ExpectedValues()
{
// Setup
var random = new Random(21);
double velocity = random.NextDouble();
double distance = random.NextDouble();
// Call
var output = new BalancedFieldLengthOutput(velocity, distance);
// Assert
Assert.That(output.Velocity, Is.EqualTo(velocity));
Assert.That(output.Distance, Is.EqualTo(distance));
}
public static void Constructor_ExpectedValues()
{
// Setup
var random = new Random(21);
var output = new BalancedFieldLengthOutput(random.NextDouble(),
random.NextDouble());
// Call
var viewModel = new OutputViewModel(output);
// Assert
Assert.That(viewModel.BalancedFieldLengthDistance, Is.EqualTo(output.Distance));
Assert.That(viewModel.BalancedFieldLengthVelocity, Is.EqualTo(output.Velocity));
}
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));
}
public void Create_WithValidCollection_ReturnsExpectedBalancedFieldLengthOutput()
{
// Setup
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)
};
// Call
BalancedFieldLengthOutput output = BalancedFieldLengthOutputFactory.Create(outputs);
// Assert
Assert.That(output.Distance, Is.EqualTo(expectedDistance));
Assert.That(output.Velocity, Is.EqualTo(expectedVelocity));
}
