Example #1
0
        public static void Calculate_WithArguments_ExecutesDistanceCalculatorsAndReturnsExpectedOutput()
        {
            // Setup
            var random = new Random(21);

            AircraftData        aircraftData              = AircraftDataTestFactory.CreateRandomAircraftData();
            var                 integrator                = Substitute.For <IIntegrator>();
            int                 nrOfFailedEngines         = random.Next();
            double              density                   = random.NextDouble();
            double              gravitationalAcceleration = random.NextDouble();
            CalculationSettings calculationSettings       = CalculationSettingsTestFactory.CreateDistanceCalculatorSettings();

            var abortedTakeOffDistanceCalculator = Substitute.For <IDistanceCalculator>();
            var abortedTakeOffDistanceOutput     = new DistanceCalculatorOutput(calculationSettings.FailureSpeed, random.NextDouble());

            abortedTakeOffDistanceCalculator.Calculate().Returns(abortedTakeOffDistanceOutput);

            var continuedTakeOffDistanceCalculator = Substitute.For <IDistanceCalculator>();
            var continuedTakeOffDistanceOutput     = new DistanceCalculatorOutput(calculationSettings.FailureSpeed, random.NextDouble());

            continuedTakeOffDistanceCalculator.Calculate().Returns(continuedTakeOffDistanceOutput);

            var distanceCalculatorFactory = Substitute.For <IDistanceCalculatorFactory>();

            distanceCalculatorFactory.CreateAbortedTakeOffDistanceCalculator(Arg.Is(aircraftData),
                                                                             Arg.Is(integrator),
                                                                             Arg.Is(density),
                                                                             Arg.Is(gravitationalAcceleration),
                                                                             Arg.Is(calculationSettings))
            .Returns(abortedTakeOffDistanceCalculator);
            distanceCalculatorFactory.CreateContinuedTakeOffDistanceCalculator(Arg.Is(aircraftData),
                                                                               Arg.Is(integrator),
                                                                               Arg.Is(nrOfFailedEngines),
                                                                               Arg.Is(density),
                                                                               Arg.Is(gravitationalAcceleration),
                                                                               Arg.Is(calculationSettings))
            .Returns(continuedTakeOffDistanceCalculator);

            var aggregatedCalculator = new Calculator.AggregatedDistanceCalculator.AggregatedDistanceCalculator(distanceCalculatorFactory);

            // Call
            AggregatedDistanceOutput output = aggregatedCalculator.Calculate(aircraftData, integrator, nrOfFailedEngines, density, gravitationalAcceleration, calculationSettings);

            // Assert
            Assert.AreEqual(calculationSettings.FailureSpeed, output.FailureSpeed);
            Assert.AreEqual(abortedTakeOffDistanceOutput.Distance, output.AbortedTakeOffDistance);
            Assert.AreEqual(continuedTakeOffDistanceOutput.Distance, output.ContinuedTakeOffDistance);
        }
Example #2
0
        public AggregatedDistanceOutput Calculate(AircraftData aircraftData,
                                                  IIntegrator integrator,
                                                  int nrOfFailedEngines,
                                                  double density,
                                                  double gravitationalAcceleration,
                                                  CalculationSettings calculationSettings)
        {
            if (aircraftData == null)
            {
                throw new ArgumentNullException(nameof(aircraftData));
            }

            if (integrator == null)
            {
                throw new ArgumentNullException(nameof(integrator));
            }

            if (calculationSettings == null)
            {
                throw new ArgumentNullException(nameof(calculationSettings));
            }

            IDistanceCalculator abortedTakeOffCalculator = distanceCalculatorFactory.CreateAbortedTakeOffDistanceCalculator(aircraftData,
                                                                                                                            integrator,
                                                                                                                            density,
                                                                                                                            gravitationalAcceleration,
                                                                                                                            calculationSettings);

            IDistanceCalculator continuedTakeOffCalculator = distanceCalculatorFactory.CreateContinuedTakeOffDistanceCalculator(aircraftData,
                                                                                                                                integrator,
                                                                                                                                nrOfFailedEngines,
                                                                                                                                density,
                                                                                                                                gravitationalAcceleration,
                                                                                                                                calculationSettings);

            DistanceCalculatorOutput abortedTakeOffOutput   = abortedTakeOffCalculator.Calculate();
            DistanceCalculatorOutput continuedTakeOffOutput = continuedTakeOffCalculator.Calculate();

            return(new AggregatedDistanceOutput(calculationSettings.FailureSpeed,
                                                abortedTakeOffOutput.Distance,
                                                continuedTakeOffOutput.Distance));
        }
Example #3
0
        public static void Calculate_AbortedTakeOffDistanceCalculatorThrowsCalculatorException_ThrowsCalculatorException()
        {
            // Setup
            var random = new Random(21);

            AircraftData        aircraftData              = AircraftDataTestFactory.CreateRandomAircraftData();
            var                 integrator                = Substitute.For <IIntegrator>();
            int                 nrOfFailedEngines         = random.Next();
            double              density                   = random.NextDouble();
            double              gravitationalAcceleration = random.NextDouble();
            CalculationSettings calculationSettings       = CalculationSettingsTestFactory.CreateDistanceCalculatorSettings();

            var calculatorException = new CalculatorException();
            var abortedTakeOffDistanceCalculator = Substitute.For <IDistanceCalculator>();

            abortedTakeOffDistanceCalculator.Calculate().Throws(calculatorException);

            var continuedTakeOffDistanceCalculator = Substitute.For <IDistanceCalculator>();
            var continuedTakeOffDistanceOutput     = new DistanceCalculatorOutput(calculationSettings.FailureSpeed, random.NextDouble());

            continuedTakeOffDistanceCalculator.Calculate().Returns(continuedTakeOffDistanceOutput);

            var distanceCalculatorFactory = Substitute.For <IDistanceCalculatorFactory>();

            distanceCalculatorFactory.CreateAbortedTakeOffDistanceCalculator(null, null, 0, 0, null).ReturnsForAnyArgs(abortedTakeOffDistanceCalculator);

            var aggregatedCalculator = new Calculator.AggregatedDistanceCalculator.AggregatedDistanceCalculator(distanceCalculatorFactory);

            // Call
            TestDelegate call = () => aggregatedCalculator.Calculate(aircraftData, integrator, nrOfFailedEngines, density, gravitationalAcceleration, calculationSettings);

            // Assert
            var exception = Assert.Throws <CalculatorException>(call);

            Assert.AreSame(calculatorException, exception);
        }
Example #4
0
        public void GivenCalculator_WhenCalculatingAndSolutionConvergesWithScreenHeightAfterFailureDynamics_ThenCallsInExpectedOrderAndOutputReturned()
        {
            // Given
            var          random        = new Random(21);
            const double screenHeight  = 10.7;
            int          nrOfTimeSteps = random.Next(3, int.MaxValue);
            double       timeStep      = random.NextDouble();
            int          failureSpeed  = random.Next();

            var failureState = new AircraftState(random.NextAngle(),
                                                 random.NextAngle(),
                                                 failureSpeed + 0.1,
                                                 random.NextDouble(),
                                                 random.NextDouble());

            AircraftState[] states =
            {
                failureState,
                CreateAircraftStateWithHeight(screenHeight - 0.2),
                CreateAircraftStateWithHeight(screenHeight)
            };

            AircraftAccelerations[] accelerations =
            {
                CreateAircraftAccelerations(),
                CreateAircraftAccelerations(),
                CreateAircraftAccelerations()
            };

            var normalTakeOffDynamicsCalculator = Substitute.For <INormalTakeOffDynamicsCalculator>();

            normalTakeOffDynamicsCalculator.Calculate(Arg.Any <AircraftState>())
            .Returns(accelerations[0]);

            var failureTakeOffDynamicsCalculator = Substitute.For <IFailureTakeOffDynamicsCalculator>();

            failureTakeOffDynamicsCalculator.Calculate(Arg.Any <AircraftState>())
            .Returns(accelerations[1], accelerations[2]);

            var integrator = Substitute.For <IIntegrator>();

            integrator.Integrate(Arg.Any <AircraftState>(), Arg.Any <AircraftAccelerations>(), timeStep)
            .Returns(states[0], states[1], states[2]);

            var calculatorSettings = new CalculationSettings(failureSpeed, nrOfTimeSteps, timeStep);
            var calculator         = new DistanceCalculator(normalTakeOffDynamicsCalculator, failureTakeOffDynamicsCalculator,
                                                            integrator, calculatorSettings);

            // Call
            DistanceCalculatorOutput output = calculator.Calculate();

            // Assert
            normalTakeOffDynamicsCalculator.Received(1).Calculate(Arg.Any <AircraftState>());
            failureTakeOffDynamicsCalculator.Received(2).Calculate(Arg.Any <AircraftState>());
            integrator.Received(3).Integrate(Arg.Any <AircraftState>(), Arg.Any <AircraftAccelerations>(), timeStep);
            Received.InOrder(() =>
            {
                normalTakeOffDynamicsCalculator.Calculate(Arg.Is <AircraftState>(state => IsZeroAircraftState(state)));
                integrator.Integrate(Arg.Is <AircraftState>(state => IsZeroAircraftState(state)), accelerations[0], timeStep);

                failureTakeOffDynamicsCalculator.Calculate(states[0]);
                integrator.Integrate(states[0], accelerations[1], timeStep);

                failureTakeOffDynamicsCalculator.Calculate(states[1]);
                integrator.Integrate(states[1], accelerations[2], timeStep);
            });

            Assert.AreEqual(states.Last().Distance, output.Distance);
            Assert.AreEqual(failureSpeed, output.FailureSpeed);
        }