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