예제 #1
0
        public void Calculate_NormalDynamicsCalculatorThrowsException_ThenExceptionRethrown()
        {
            // Setup
            var calculatorException             = new CalculatorException();
            var normalTakeOffDynamicsCalculator = Substitute.For <INormalTakeOffDynamicsCalculator>();

            normalTakeOffDynamicsCalculator.Calculate(Arg.Any <AircraftState>())
            .Throws(calculatorException);

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

            var calculator = new DistanceCalculator(normalTakeOffDynamicsCalculator,
                                                    failureTakeOffDynamicsCalculator,
                                                    integrator,
                                                    CalculationSettingsTestFactory.CreateDistanceCalculatorSettings());

            // Call
            TestDelegate call = () => calculator.Calculate();

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

            Assert.AreSame(calculatorException, exception);
        }
예제 #2
0
        public static void Calculate_ContinuedTakeOffDistanceCalculatorThrowsCalculatorException_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 continuedTakeOffDistanceCalculator = Substitute.For <IDistanceCalculator>();

            continuedTakeOffDistanceCalculator.Calculate().Throws(calculatorException);

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

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

            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);
        }
예제 #3
0
        public void CreateDistanceCalculatorSettings_Always_ReturnsExpectedValues()
        {
            // Call
            CalculationSettings settings = CalculationSettingsTestFactory.CreateDistanceCalculatorSettings();

            // Assert
            Assert.IsNotNull(settings);
            Assert.Greater(settings.FailureSpeed, 0);
            Assert.Greater(settings.MaximumNrOfTimeSteps, 0);
            Assert.IsTrue(IsConcreteNumber(settings.TimeStep));
        }
예제 #4
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);
        }
예제 #5
0
        public void Constructor_IntegratorNull_ThrowsArgumentNullException()
        {
            // Setup
            var normalTakeOffDynamicsCalculator  = Substitute.For <INormalTakeOffDynamicsCalculator>();
            var failureTakeOffDynamicsCalculator = Substitute.For <IFailureTakeOffDynamicsCalculator>();

            // Call
            TestDelegate call = () => new DistanceCalculator(normalTakeOffDynamicsCalculator,
                                                             failureTakeOffDynamicsCalculator,
                                                             null,
                                                             CalculationSettingsTestFactory.CreateDistanceCalculatorSettings());

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

            Assert.AreEqual("integrator", exception.ParamName);
        }
예제 #6
0
        public static void Constructor_ExpectedValues()
        {
            // Setup
            var normalTakeOffDynamicsCalculator  = Substitute.For <INormalTakeOffDynamicsCalculator>();
            var failureTakeOffDynamicsCalculator = Substitute.For <IFailureTakeOffDynamicsCalculator>();
            var integrator = Substitute.For <IIntegrator>();
            CalculationSettings calculationSettings = CalculationSettingsTestFactory.CreateDistanceCalculatorSettings();

            // Call
            var calculator = new DistanceCalculator(normalTakeOffDynamicsCalculator,
                                                    failureTakeOffDynamicsCalculator,
                                                    integrator,
                                                    calculationSettings);

            // Assert
            Assert.IsInstanceOf <IDistanceCalculator>(calculator);
        }
예제 #7
0
        public void Calculate_IntegratorNull_ThrowsArgumentNullException()
        {
            // Setup
            var random = new Random(21);

            AircraftData        aircraftData              = AircraftDataTestFactory.CreateRandomAircraftData();
            int                 nrOfFailedEngines         = random.Next();
            double              density                   = random.NextDouble();
            double              gravitationalAcceleration = random.NextDouble();
            CalculationSettings calculationSettings       = CalculationSettingsTestFactory.CreateDistanceCalculatorSettings();

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

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

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

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

            Assert.AreEqual("integrator", exception.ParamName);
        }
예제 #8
0
        public void CreateContinuedTakeOffDistanceCalculator_WithValidArguments_ReturnsExpectedCalculator()
        {
            // Setup
            var    random  = new Random(21);
            double density = random.NextDouble();
            double gravitationalAcceleration = random.NextDouble();
            int    nrOfFailedEngines         = random.Next();

            AircraftData aircraftData = AircraftDataTestFactory.CreateRandomAircraftData();

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

            var takeOffDynamicsCalculatorFactory = Substitute.For <ITakeOffDynamicsCalculatorFactory>();

            takeOffDynamicsCalculatorFactory.CreateNormalTakeOffDynamics(aircraftData, density, gravitationalAcceleration)
            .Returns(normalTakeOffDynamicsCalculator);
            takeOffDynamicsCalculatorFactory.CreateContinuedTakeOffDynamicsCalculator(aircraftData, nrOfFailedEngines, density, gravitationalAcceleration)
            .Returns(failureTakeOffDynamicsCalculator);

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

            IDistanceCalculatorFactory factory = new DistanceCalculatorFactory(takeOffDynamicsCalculatorFactory);

            // Call
            IDistanceCalculator calculator = factory.CreateContinuedTakeOffDistanceCalculator(aircraftData,
                                                                                              integrator,
                                                                                              nrOfFailedEngines,
                                                                                              density,
                                                                                              gravitationalAcceleration,
                                                                                              CalculationSettingsTestFactory.CreateDistanceCalculatorSettings());

            // Assert
            takeOffDynamicsCalculatorFactory.DidNotReceiveWithAnyArgs().CreateAbortedTakeOffDynamics(Arg.Any <AircraftData>(),
                                                                                                     Arg.Any <double>(),
                                                                                                     Arg.Any <double>());
            takeOffDynamicsCalculatorFactory.Received(1).CreateNormalTakeOffDynamics(Arg.Any <AircraftData>(),
                                                                                     Arg.Any <double>(),
                                                                                     Arg.Any <double>());
            takeOffDynamicsCalculatorFactory.Received(1).CreateContinuedTakeOffDynamicsCalculator(Arg.Any <AircraftData>(),
                                                                                                  Arg.Any <int>(),
                                                                                                  Arg.Any <double>(),
                                                                                                  Arg.Any <double>());

            Assert.IsInstanceOf <DistanceCalculator>(calculator);
        }