public void ShouldReturnZeroRoutesIfTheDestinationIsALeaf()
{
var railroad = GivenA.SimpleRailRoad();
var routes = new LimitedStopsRouteFinder().Find(railroad, new City("A"), new City("C"), 10);
routes.Should().Be(0);
}
public void Should_Throw_NoRouteException_If_The_Destination_Is_A_Leaf()
{
var railRoad = GivenA.SimpleRailRoad();
Action act = () => routesFinder.GetNumberOfRoutesWithDistanceLimit(railRoad, new City("A"), new City("Z"), 120);
act.ShouldThrow <NoRouteException>();
}
public void ShouldCalculateTheDistanceOfRoutesWithMultipleCities(string routeDescription, int expectedDistance)
{
var railroad = GivenA.RailRoadWithMultipleTracks();
int distance = new DistanceEvaluator().MeasureTheDistance(railroad, Route.Parse(routeDescription));
distance.Should().Be(expectedDistance);
}
public void Should_Find_A_Single_Possible_Route_On_Simple_RailRoad_With_A_Single_Stop()
{
var railroad = GivenA.SimpleRailRoad();
var possibleRoutes = routeFinder.FindPossibleRoutes(railroad, new City("A"), new City("B"), 1);
possibleRoutes.Should().Be(1);
}
public void Should_Find_All_The_Possible_Routes_From_A_To_C_With_Exactly_4_Stops()
{
var railroad = GivenA.RailRoadWithMultipleTracks();
var possibleRoutes = routeFinder.FindPossibleRoutes(railroad, new City("A"), new City("C"), 4);
possibleRoutes.Should().Be(3);
}
public void Should_Throw_NoRouteException_If_The_Destination_Is_A_Leaf()
{
var railRoad = GivenA.SimpleRailRoad();
Action act = () => routesFinder.GetDistanceOfShortestRoute(railRoad, new City("A"), new City("Z"));
act.ShouldThrow <NoRouteException>();
}
public void Should_Return_Zero_Routes_If_The_Destination_Is_A_Leaf()
{
var railRoad = GivenA.SimpleRailRoad();
var leaf = new City("Z");
routeFinder.FindPossibleRoutes(railRoad, new City("A"), leaf, 1).Should().Be(0);
}
public void ShouldGetAListOfPossibleRoutesFromCityToCityInAComplexRailRoad(string origin, string destination, int maximumStops, int possibleRoutes)
{
var railroad = GivenA.RailRoadWithMultipleTracks();
var routes = new LimitedStopsRouteFinder().Find(railroad, new City(origin), new City(destination), maximumStops);
routes.Should().Be(possibleRoutes);
}
public void ShouldCalcuteTheCostOfASimpleRouteFrom_CityTo_City(string routeDescription, int expectedDistance)
{
var railroad = GivenA.RailRoadWithMultipleTracks();
var route = Route.Parse(routeDescription);
int distance = new DistanceEvaluator().MeasureTheDistance(railroad, route);
distance.Should().Be(expectedDistance);
}
public void Should_Ask_To_Discover_The_Number_Of_Different_Routes_From_C_To_C_With_A_Distance_Less_Than_30()
{
var railRoad = GivenA.RailRoadWithMultipleTracks();
railRoadFactoryMock.Setup(x => x.Create(It.IsAny <string>())).Returns(railRoad);
railRoadService.Run();
numberOfRoutesWithDistanceLimitFinderMock.Verify(x => x.GetNumberOfRoutesWithDistanceLimit(railRoad, new City("C"), new City("C"), 30), Times.Once());
}
public void ShouldNotModifyTheRouteAfterMeasureTheDistance(string routeDescription)
{
var railroad = GivenA.RailRoadWithMultipleTracks();
var route = Route.Parse(routeDescription);
new DistanceEvaluator().MeasureTheDistance(railroad, route);
Route originalRoute = Route.Parse(routeDescription);
route.Cities.Count.Should().Be(originalRoute.Cities.Count);
}
public void Should_Ask_To_Discover_The_Number_Of_Trips_From_A_To_C_With_Exactly_4_Stops()
{
var railRoad = GivenA.SimpleRailRoad();
railRoadFactoryMock.Setup(x => x.Create(It.IsAny <string>())).Returns(railRoad);
railRoadService.Run();
exactNuberStopsRouteFinderMock.Verify(x => x.FindPossibleRoutes(railRoad, new City("A"), new City("C"), 4), Times.Once());
}
public void Should_Ask_To_Discover_The_Number_Of_Trips_From_C_To_C_With_A_Limit_Of_3_Stops()
{
var railRoad = GivenA.SimpleRailRoad();
railRoadFactoryMock.Setup(x => x.Create(It.IsAny <string>())).Returns(railRoad);
railRoadService.Run();
limitedStopsRouteFinderMock.Verify(x => x.Find(railRoad, new City("C"), new City("C"), 3), Times.Once());
}
public void Should_Ask_For_Distance_Measurment_Of_The_Predetermined_Routes(string route)
{
var railRoad = GivenA.SimpleRailRoad();
railRoadFactoryMock.Setup(x => x.Create(It.IsAny <string>())).Returns(railRoad);
railRoadService.Run();
distanceEvaluator.Verify(x => x.MeasureTheDistance(railRoad, Route.Parse(route)), Times.Once());
}
public void Should_Ask_For_The_Length_Of_Shortest_Route_From_City_To_City(string origin, string destination)
{
var railRoad = GivenA.SimpleRailRoad();
railRoadFactoryMock.Setup(x => x.Create(It.IsAny <string>())).Returns(railRoad);
railRoadService.Run();
shortestRoutFinderMock.Verify(x => x.GetDistanceOfShortestRoute(railRoad, new City(origin), new City(destination)), Times.Once());
}
public void ShouldThrowANoRouteExceptionIfTheRouteDoesNotExist(string routeDescription, bool shouldThrowException)
{
var railroad = GivenA.RailRoadWithMultipleTracks();
Action act = () => new DistanceEvaluator().MeasureTheDistance(railroad, Route.Parse(routeDescription));
if (shouldThrowException)
{
act.ShouldThrow <NoRouteException>("There is no such route!");
}
else
{
act.ShouldNotThrow <NoRouteException>("This route exists!");
}
}
public void ShouldAppendCitiesInTheRoute()
{
var route = new Route();
var expectedCities = GivenA.ListOfCities();
foreach (var city in expectedCities)
{
route.AppendCity(city);
}
route.Cities.Count.Should().Be(expectedCities.Count);
foreach (var expectedCity in expectedCities)
{
route.Cities.Should().Contain(expectedCity);
}
}
public void Should_Find_Shortest_Track_From_A_RailRoad_With_Multiple_Tracks(string origin, string destination, int shortestRoute)
{
var railroad = GivenA.RailRoadWithMultipleTracks();
routesFinder.GetDistanceOfShortestRoute(railroad, new City(origin), new City(destination)).Should().Be(shortestRoute);
}
public void Should_Find_Simple_Routes_With_Limited_Distances_On_A_Complex_RailRoad()
{
var railRoad = GivenA.RailRoadWithMultipleTracks();
routesFinder.GetNumberOfRoutesWithDistanceLimit(railRoad, new City("C"), new City("C"), 30).Should().Be(7);
}
