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