public void Create_WithArguments_ReturnsExpectedAircraftData()
        {
            // Setup
            var random = new Random(21);

            var aircraftData = new AircraftData
            {
                WingSurfaceArea         = random.NextDouble(),
                AspectRatio             = random.NextDouble(),
                OswaldFactor            = random.NextDouble(),
                MaximumLiftCoefficient  = random.NextDouble(),
                LiftCoefficientGradient = random.NextDouble(),
                ZeroLiftAngleOfAttack   = random.NextAngle(),
                RestDragCoefficient     = random.NextDouble(),
                RestDragCoefficientWithEngineFailure = random.NextDouble(),
                MaximumPitchAngle                   = random.NextAngle(),
                PitchGradient                       = random.NextAngle(),
                RollResistanceCoefficient           = random.NextDouble(),
                RollResistanceWithBrakesCoefficient = random.NextDouble(),
                TakeOffWeight                       = random.NextDouble()
            };

            var engineData = new EngineData
            {
                NrOfEngines     = random.Next(),
                ThrustPerEngine = random.NextDouble()
            };

            // Call
            KernelAircraftData data = AircraftDataFactory.Create(aircraftData, engineData);

            // Assert
            AircraftDataTestHelper.AssertAircraftData(aircraftData, engineData, data);
        }
        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 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));
            }
        }