@Test
public void whenAddingDeliverShipmentWithVehDiffStartEndLocs_constraintShouldWork() {
Shipment shipment =
Shipment.Builder.newInstance("s")
.setPickupLocation(Location.newInstance(0, 1))
.setDeliveryLocation(Location.newInstance(4, 1))
.build();
VehicleImpl vehicle =
VehicleImpl.Builder.newInstance("v")
.setStartLocation(Location.newInstance(0, 0))
.setEndLocation(Location.newInstance(0, 4))
.build();
final VehicleRoutingProblem vrp =
VehicleRoutingProblem.Builder.newInstance().addJob(shipment).addVehicle(vehicle).build();
VehicleRoute route = VehicleRoute.emptyRoute();
JobInsertionContext context = new JobInsertionContext(route, shipment, vehicle, null, 0);
context.getAssociatedActivities().add(vrp.getActivities(shipment).get(0));
context.getAssociatedActivities().add(vrp.getActivities(shipment).get(1));
maxDistanceMap = new HashMap<>();
maxDistanceMap.put(vehicle, 10d);
StateManager stateManager = new StateManager(vrp);
MaxDistanceConstraint maxDistanceConstraint =
new MaxDistanceConstraint(
stateManager,
traveledDistanceId,
new TransportDistance() {
@Override
public double getDistance(
Location from, Location to, double departureTime, Vehicle vehicle) {
return vrp.getTransportCosts()
.getTransportTime(from, to, departureTime, null, vehicle);
}
},
maxDistanceMap);
Assert.assertTrue(
maxDistanceConstraint
.fulfilled(
context,
new Start(vehicle.getStartLocation(), 0, Double.MAX_VALUE),
vrp.getActivities(shipment).get(0),
new End(vehicle.getEndLocation(), 0, Double.MAX_VALUE),
0)
.equals(HardActivityConstraint.ConstraintsStatus.FULFILLED));
ActivityContext pickupContext = new ActivityContext();
pickupContext.setArrivalTime(1);
pickupContext.setEndTime(1);
pickupContext.setInsertionIndex(0);
context.setRelatedActivityContext(pickupContext);
Assert.assertTrue(
maxDistanceConstraint
.fulfilled(
context,
vrp.getActivities(shipment).get(0),
vrp.getActivities(shipment).get(1),
new End(vehicle.getEndLocation(), 0, Double.MAX_VALUE),
1)
.equals(HardActivityConstraint.ConstraintsStatus.FULFILLED));
}
@Before
public void doBefore() {
routingCosts = CostFactory.createManhattanCosts();
activityCosts = new WaitingTimeCosts();
VehicleRoutingProblem vrpMock = mock(VehicleRoutingProblem.class);
when(vrpMock.getFleetSize()).thenReturn(VehicleRoutingProblem.FleetSize.FINITE);
stateManager = new StateManager(vrpMock);
reverseActivityVisitor = new ReverseRouteActivityVisitor();
reverseActivityVisitor.addActivityVisitor(
new UpdatePracticalTimeWindows(stateManager, routingCosts, activityCosts));
Pickup pickup =
(Pickup)
Pickup.Builder.newInstance("pick")
.setLocation(Location.newInstance("0,20"))
.setTimeWindow(TimeWindow.newInstance(0, 30))
.build();
Delivery delivery =
(Delivery)
Delivery.Builder.newInstance("del")
.setLocation(Location.newInstance("20,20"))
.setTimeWindow(TimeWindow.newInstance(10, 40))
.build();
Pickup pickup2 =
(Pickup)
Pickup.Builder.newInstance("pick2")
.setLocation(Location.newInstance("20,0"))
.setTimeWindow(TimeWindow.newInstance(20, 50))
.build();
Vehicle vehicle =
VehicleImpl.Builder.newInstance("v")
.setStartLocation(Location.newInstance("0,0"))
.setType(mock(VehicleType.class))
.build();
VehicleRoutingProblem.Builder vrpBuilder = VehicleRoutingProblem.Builder.newInstance();
final VehicleRoutingProblem vrp =
vrpBuilder.addJob(pickup).addJob(pickup2).addJob(delivery).build();
route =
VehicleRoute.Builder.newInstance(vehicle, mock(Driver.class))
.setJobActivityFactory(
new JobActivityFactory() {
@Override
public List<AbstractActivity> createActivities(Job job) {
return vrp.copyAndGetActivities(job);
}
})
.addService(pickup)
.addService(delivery)
.addService(pickup2)
.build();
reverseActivityVisitor.visit(route);
}
private void ruin(
Collection<VehicleRoute> vehicleRoutes, int nOfJobs2BeRemoved, List<Job> unassignedJobs) {
if (vrp.getJobs().values().size() == 0) return;
Map<Job, VehicleRoute> mappedRoutes = map(vehicleRoutes);
int toRemove = nOfJobs2BeRemoved;
Collection<Job> lastRemoved = new ArrayList<Job>();
Set<VehicleRoute> ruined = new HashSet<VehicleRoute>();
Set<Job> removed = new HashSet<Job>();
Set<VehicleRoute> cycleCandidates = new HashSet<VehicleRoute>();
while (toRemove > 0) {
Job target;
VehicleRoute targetRoute = null;
if (lastRemoved.isEmpty()) {
target = RandomUtils.nextJob(vrp.getJobs().values(), random);
targetRoute = mappedRoutes.get(target);
} else {
target = RandomUtils.nextJob(lastRemoved, random);
Iterator<Job> neighborIterator =
jobNeighborhoods.getNearestNeighborsIterator(nOfJobs2BeRemoved, target);
while (neighborIterator.hasNext()) {
Job j = neighborIterator.next();
if (!removed.contains(j) && !ruined.contains(mappedRoutes.get(j))) {
targetRoute = mappedRoutes.get(j);
break;
}
}
lastRemoved.clear();
}
if (targetRoute == null) break;
if (cycleCandidates.contains(targetRoute)) break;
if (ruined.contains(targetRoute)) {
cycleCandidates.add(targetRoute);
break;
}
DBSCANClusterer dbscan = new DBSCANClusterer(vrp.getTransportCosts());
dbscan.setRandom(random);
dbscan.setMinPts(minPts);
dbscan.setEpsFactor(epsFactor);
List<Job> cluster = dbscan.getRandomCluster(targetRoute);
for (Job j : cluster) {
if (toRemove == 0) break;
if (removeJob(j, vehicleRoutes)) {
lastRemoved.add(j);
unassignedJobs.add(j);
}
toRemove--;
}
ruined.add(targetRoute);
}
}
private List<Job> getUnassignedJobs(VehicleRoutingProblem vrp) {
ArrayList<Job> jobs = new ArrayList<>(vrp.getJobs().values());
// for (Vehicle v : vrp.getVehicles()) {
// if (v.getBreak() != null) jobs.add(v.getBreak());
// }
return jobs;
}
private Set<String> getInitialVehicleIds(VehicleRoutingProblem vehicleRoutingProblem) {
Set<String> ids = new HashSet<String>();
for (VehicleRoute r : vehicleRoutingProblem.getInitialVehicleRoutes()) {
ids.add(r.getVehicle().getId());
}
return ids;
}
private Map<Job, VehicleRoute> map(Collection<VehicleRoute> vehicleRoutes) {
Map<Job, VehicleRoute> map = new HashMap<Job, VehicleRoute>(vrp.getJobs().size());
for (VehicleRoute r : vehicleRoutes) {
for (Job j : r.getTourActivities().getJobs()) {
map.put(j, r);
}
}
return map;
}
private double c(TourActivity from, TourActivity to, Vehicle vehicle) {
return vrp.getTransportCosts()
.getTransportCost(
from.getLocation(),
to.getLocation(),
from.getEndTime(),
DriverImpl.noDriver(),
vehicle);
}
private void ruin(
Collection<VehicleRoute> vehicleRoutes, int nOfJobs2BeRemoved, List<Job> unassignedJobs) {
LinkedList<Job> availableJobs = new LinkedList<Job>(vrp.getJobs().values());
int toRemove = nOfJobs2BeRemoved;
while (toRemove > 0) {
Job worst = getWorst(vehicleRoutes);
if (worst == null) break;
if (removeJob(worst, vehicleRoutes)) {
availableJobs.remove(worst);
unassignedJobs.add(worst);
}
toRemove--;
}
}
@Test
public void itShouldSolveProblemWithIniSolutionExternallyCreated() {
Service s1 = Service.Builder.newInstance("s1").setLocation(Location.newInstance(10, 0)).build();
Service s2 = Service.Builder.newInstance("s2").setLocation(Location.newInstance(0, 10)).build();
VehicleImpl vehicle =
VehicleImpl.Builder.newInstance("v1").setStartLocation(Location.newInstance(0, 0)).build();
VehicleRoutingProblem vrp =
VehicleRoutingProblem.Builder.newInstance()
.addJob(s1)
.addJob(s2)
.addVehicle(vehicle)
.build();
VehicleRoutingAlgorithm vra = Jsprit.createAlgorithm(vrp);
/*
create ini sol
*/
VehicleRoute route1 =
VehicleRoute.Builder.newInstance(vehicle)
.setJobActivityFactory(vrp.getJobActivityFactory())
.addService(s1)
.build();
vra.addInitialSolution(new VehicleRoutingProblemSolution(Arrays.asList(route1), 20.));
try {
vra.searchSolutions();
Assert.assertTrue(true);
} catch (Exception e) {
Assert.assertFalse(true);
}
}
@Override
public VehicleRoutingProblemSolution createSolution(final VehicleRoutingProblem vrp) {
logger.info("create initial solution");
List<VehicleRoute> vehicleRoutes = new ArrayList<>();
vehicleRoutes.addAll(vrp.getInitialVehicleRoutes());
Collection<Job> badJobs = insertion.insertJobs(vehicleRoutes, getUnassignedJobs(vrp));
VehicleRoutingProblemSolution solution =
new VehicleRoutingProblemSolution(vehicleRoutes, badJobs, Double.MAX_VALUE);
double costs = solutionCostsCalculator.getCosts(solution);
solution.setCost(costs);
if (solutionCostsCalculator instanceof ModularSolutionCostCalculator) {
ModularSolutionCostCalculator modCalc =
(ModularSolutionCostCalculator) solutionCostsCalculator;
solution.setDetailedCost(modCalc.calculate(solution));
}
return solution;
}
public static void addCoreConstraints(
ConstraintManager constraintManager,
StateManager stateManager,
final VehicleRoutingProblem vrp) {
constraintManager.addTimeWindowConstraint();
constraintManager.addLoadConstraint();
constraintManager.addSkillsConstraint();
constraintManager.addConstraint(new SwitchNotFeasible(stateManager));
stateManager.updateLoadStates();
stateManager.updateTimeWindowStates();
UpdateVehicleDependentPracticalTimeWindows twUpdater =
new UpdateVehicleDependentPracticalTimeWindows(
stateManager, vrp.getTransportCosts(), vrp.getActivityCosts());
twUpdater.setVehiclesToUpdate(
new UpdateVehicleDependentPracticalTimeWindows.VehiclesToUpdate() {
Map<VehicleTypeKey, Vehicle> uniqueTypes = new HashMap<VehicleTypeKey, Vehicle>();
@Override
public Collection<Vehicle> get(VehicleRoute vehicleRoute) {
if (uniqueTypes.isEmpty()) {
for (Vehicle v : vrp.getVehicles()) {
if (!uniqueTypes.containsKey(v.getVehicleTypeIdentifier())) {
uniqueTypes.put(v.getVehicleTypeIdentifier(), v);
}
}
}
Collection<Vehicle> vehicles = new ArrayList<Vehicle>();
vehicles.addAll(uniqueTypes.values());
return vehicles;
}
});
stateManager.addStateUpdater(new UpdateEndLocationIfRouteIsOpen());
stateManager.addStateUpdater(twUpdater);
stateManager.updateSkillStates();
stateManager.addStateUpdater(
new UpdateActivityTimes(
vrp.getTransportCosts(),
ActivityTimeTracker.ActivityPolicy.AS_SOON_AS_TIME_WINDOW_OPENS,
vrp.getActivityCosts()));
stateManager.addStateUpdater(
new UpdateVariableCosts(vrp.getActivityCosts(), vrp.getTransportCosts(), stateManager));
stateManager.addStateUpdater(
new UpdateFutureWaitingTimes(stateManager, vrp.getTransportCosts()));
}
private void initialise() {
this.stateManager = new StateManager(vrp);
this.stateManager.updateTimeWindowStates();
this.stateManager.updateLoadStates();
this.stateManager.updateSkillStates();
activityPolicy = ActivityTimeTracker.ActivityPolicy.AS_SOON_AS_TIME_WINDOW_OPENS;
this.stateManager.addStateUpdater(
new UpdateActivityTimes(vrp.getTransportCosts(), activityPolicy, vrp.getActivityCosts()));
this.stateManager.addStateUpdater(
new UpdateVariableCosts(vrp.getActivityCosts(), vrp.getTransportCosts(), stateManager));
waiting_time_id = stateManager.createStateId("waiting-time");
transport_time_id = stateManager.createStateId("transport-time");
service_time_id = stateManager.createStateId("service-time");
distance_id = stateManager.createStateId("distance");
too_late_id = stateManager.createStateId("too-late");
shipment_id = stateManager.createStateId("shipment");
backhaul_id = stateManager.createStateId("backhaul");
skill_id = stateManager.createStateId("skills-violated");
last_transport_cost_id = stateManager.createStateId("last-transport-cost");
last_transport_distance_id = stateManager.createStateId("last-transport-distance");
last_transport_time_id = stateManager.createStateId("last-transport-time");
stateManager.addStateUpdater(
new SumUpActivityTimes(
waiting_time_id,
transport_time_id,
service_time_id,
too_late_id,
stateManager,
activityPolicy,
vrp.getActivityCosts()));
stateManager.addStateUpdater(
new DistanceUpdater(distance_id, stateManager, distanceCalculator));
stateManager.addStateUpdater(
new BackhaulAndShipmentUpdater(backhaul_id, shipment_id, stateManager));
stateManager.addStateUpdater(new SkillUpdater(stateManager, skill_id));
stateManager.addStateUpdater(new LoadAndActivityCounter(stateManager));
stateManager.addStateUpdater(
new LastTransportUpdater(
stateManager,
vrp.getTransportCosts(),
distanceCalculator,
last_transport_distance_id,
last_transport_time_id,
last_transport_cost_id));
}
@Test
public void whenEndLocationIsSet_constraintShouldWork() {
VehicleImpl vehicle =
VehicleImpl.Builder.newInstance("v")
.setStartLocation(Location.newInstance(0, 0))
.setEndLocation(Location.newInstance(10, 0))
.build();
Pickup pickup =
Pickup.Builder.newInstance("pickup").setLocation(Location.newInstance(10, 0)).build();
vrp = VehicleRoutingProblem.Builder.newInstance().addVehicle(vehicle).addJob(pickup).build();
route = VehicleRoute.emptyRoute();
maxDistanceMap = new HashMap<>();
maxDistanceMap.put(vehicle, 5d);
MaxDistanceConstraint maxDistanceConstraint =
new MaxDistanceConstraint(
new StateManager(vrp),
traveledDistanceId,
new TransportDistance() {
@Override
public double getDistance(
Location from, Location to, double departureTime, Vehicle vehicle) {
return vrp.getTransportCosts()
.getTransportTime(from, to, departureTime, null, vehicle);
}
},
maxDistanceMap);
JobInsertionContext context = new JobInsertionContext(route, pickup, vehicle, null, 0);
Assert.assertTrue(
maxDistanceConstraint
.fulfilled(
context,
new Start(vehicle.getStartLocation(), 0, Double.MAX_VALUE),
vrp.getActivities(pickup).get(0),
new End(vehicle.getEndLocation(), 0, Double.MAX_VALUE),
0)
.equals(HardActivityConstraint.ConstraintsStatus.NOT_FULFILLED));
}
private TourActivity newAct() {
return vrp.getActivities(newDelivery).get(0);
}
@Before
public void doBefore() {
vehicle =
VehicleImpl.Builder.newInstance("v").setStartLocation(Location.newInstance(0, 0)).build();
vehicle2 =
VehicleImpl.Builder.newInstance("v2")
.setStartLocation(Location.newInstance(10, 10))
.build();
maxDistanceMap = new HashMap<>();
maxDistanceMap.put(vehicle, 200d);
maxDistanceMap.put(vehicle2, 200d);
d1 = Delivery.Builder.newInstance("d1").setLocation(Location.newInstance(10, 10)).build();
d2 = Delivery.Builder.newInstance("d2").setLocation(Location.newInstance(20, 15)).build();
pickup = Pickup.Builder.newInstance("pickup").setLocation(Location.newInstance(50, 50)).build();
s1 =
Shipment.Builder.newInstance("s1")
.setPickupLocation(Location.newInstance(35, 30))
.setDeliveryLocation(Location.newInstance(20, 25))
.build();
newDelivery =
Delivery.Builder.newInstance("new").setLocation(Location.newInstance(-10, 10)).build();
vrp =
VehicleRoutingProblem.Builder.newInstance()
.setRoutingCost(new ManhattanCosts())
.addVehicle(vehicle)
.addVehicle(vehicle2)
.addJob(d1)
.addJob(d2)
.addJob(s1)
.addJob(pickup)
.addJob(newDelivery)
.build();
route =
VehicleRoute.Builder.newInstance(vehicle)
.setJobActivityFactory(vrp.getJobActivityFactory())
.addDelivery(d1)
.addDelivery(d2)
.addPickup(s1)
.addPickup(pickup)
.addDelivery(s1)
.build();
stateManager = new StateManager(vrp);
traveledDistanceId = stateManager.createStateId("traveledDistance");
com.graphhopper.jsprit.core.algorithm.state.VehicleDependentTraveledDistance traveledDistance =
new com.graphhopper.jsprit.core.algorithm.state.VehicleDependentTraveledDistance(
new TransportDistance() {
@Override
public double getDistance(
Location from, Location to, double departureTime, Vehicle vehicle) {
return new ManhattanCosts().getDistance(from, to, departureTime, vehicle);
}
},
stateManager,
traveledDistanceId,
Arrays.asList(vehicle, vehicle2));
stateManager.addStateUpdater(traveledDistance);
stateManager.informInsertionStarts(Arrays.asList(route), Collections.<Job>emptyList());
}
@Test(expected = UnsupportedOperationException.class)
public void
whenHavingShipmentsAndServicesInOneProblem_andInsertionShouldBeMadeOnRouteLevel_throwException() {
/* get a vehicle type-builder and build a type with the typeId "vehicleType" and a capacity of 2
*/
VehicleTypeImpl.Builder vehicleTypeBuilder =
VehicleTypeImpl.Builder.newInstance("vehicleType").addCapacityDimension(0, 2);
VehicleType vehicleType = vehicleTypeBuilder.build();
/*
* get a vehicle-builder and build a vehicle located at (10,10) with type "vehicleType"
*/
VehicleImpl.Builder vehicleBuilder = VehicleImpl.Builder.newInstance("vehicle");
vehicleBuilder.setStartLocation(Location.newInstance(10, 10));
vehicleBuilder.setType(vehicleType);
VehicleImpl vehicle = vehicleBuilder.build();
/*
* build shipments at the required locations, each with a capacity-demand of 1.
* 4 shipments
* 1: (5,7)->(6,9)
* 2: (5,13)->(6,11)
* 3: (15,7)->(14,9)
* 4: (15,13)->(14,11)
*/
Shipment shipment1 =
Shipment.Builder.newInstance("1")
.addSizeDimension(0, 1)
.setPickupLocation(TestUtils.loc(Coordinate.newInstance(5, 7)))
.setDeliveryLocation(TestUtils.loc(Coordinate.newInstance(6, 9)))
.build();
Shipment shipment2 =
Shipment.Builder.newInstance("2")
.addSizeDimension(0, 1)
.setPickupLocation(TestUtils.loc(Coordinate.newInstance(5, 13)))
.setDeliveryLocation(TestUtils.loc(Coordinate.newInstance(6, 11)))
.build();
Shipment shipment3 =
Shipment.Builder.newInstance("3")
.addSizeDimension(0, 1)
.setPickupLocation(TestUtils.loc(Coordinate.newInstance(15, 7)))
.setDeliveryLocation(TestUtils.loc(Coordinate.newInstance(14, 9)))
.build();
Shipment shipment4 =
Shipment.Builder.newInstance("4")
.addSizeDimension(0, 1)
.setPickupLocation(TestUtils.loc(Coordinate.newInstance(15, 13)))
.setDeliveryLocation(TestUtils.loc(Coordinate.newInstance(14, 11)))
.build();
/*
* build deliveries, (implicitly picked up in the depot)
* 1: (4,8)
* 2: (4,12)
* 3: (16,8)
* 4: (16,12)
*/
Delivery delivery1 =
(Delivery)
Delivery.Builder.newInstance("5")
.addSizeDimension(0, 1)
.setLocation(TestUtils.loc(Coordinate.newInstance(4, 8)))
.build();
Delivery delivery2 =
(Delivery)
Delivery.Builder.newInstance("6")
.addSizeDimension(0, 1)
.setLocation(TestUtils.loc(Coordinate.newInstance(4, 12)))
.build();
Delivery delivery3 =
(Delivery)
Delivery.Builder.newInstance("7")
.addSizeDimension(0, 1)
.setLocation(TestUtils.loc(Coordinate.newInstance(16, 8)))
.build();
Delivery delivery4 =
(Delivery)
Delivery.Builder.newInstance("8")
.addSizeDimension(0, 1)
.setLocation(TestUtils.loc(Coordinate.newInstance(16, 12)))
.build();
VehicleRoutingProblem.Builder vrpBuilder = VehicleRoutingProblem.Builder.newInstance();
vrpBuilder.addVehicle(vehicle);
vrpBuilder
.addJob(shipment1)
.addJob(shipment2)
.addJob(shipment3)
.addJob(shipment4)
.addJob(delivery1)
.addJob(delivery2)
.addJob(delivery3)
.addJob(delivery4)
.build();
VehicleRoutingProblem vrp = vrpBuilder.build();
final StateManager stateManager = new StateManager(vrp);
ConstraintManager constraintManager = new ConstraintManager(vrp, stateManager);
constraintManager.addLoadConstraint();
constraintManager.addTimeWindowConstraint();
VehicleFleetManager fleetManager =
new InfiniteFleetManagerFactory(vrp.getVehicles()).createFleetManager();
BestInsertionBuilder bestIBuilder =
new BestInsertionBuilder(vrp, fleetManager, stateManager, constraintManager);
bestIBuilder.setRouteLevel(2, 2);
@SuppressWarnings("unused")
InsertionStrategy bestInsertion = bestIBuilder.build();
}
@Test
public void
whenHavingOnlyServicesInOneProblem_andInsertionShouldBeMadeOnRouteLevel_itShouldAssertTrue() {
/* get a vehicle type-builder and build a type with the typeId "vehicleType" and a capacity of 2
*/
VehicleTypeImpl.Builder vehicleTypeBuilder =
VehicleTypeImpl.Builder.newInstance("vehicleType").addCapacityDimension(0, 2);
VehicleType vehicleType = vehicleTypeBuilder.build();
/*
* get a vehicle-builder and build a vehicle located at (10,10) with type "vehicleType"
*/
VehicleImpl.Builder vehicleBuilder = VehicleImpl.Builder.newInstance("vehicle");
vehicleBuilder.setStartLocation(Location.newInstance(10, 10));
vehicleBuilder.setType(vehicleType);
VehicleImpl vehicle = vehicleBuilder.build();
/*
* build deliveries, (implicitly picked up in the depot)
* 1: (4,8)
* 2: (4,12)
* 3: (16,8)
* 4: (16,12)
*/
Delivery delivery1 =
(Delivery)
Delivery.Builder.newInstance("5")
.addSizeDimension(0, 1)
.setLocation(Location.newInstance(4, 8))
.build();
Delivery delivery2 =
(Delivery)
Delivery.Builder.newInstance("6")
.addSizeDimension(0, 1)
.setLocation(Location.newInstance(4, 12))
.build();
Delivery delivery3 =
(Delivery)
Delivery.Builder.newInstance("7")
.addSizeDimension(0, 1)
.setLocation(Location.newInstance(16, 8))
.build();
Delivery delivery4 =
(Delivery)
Delivery.Builder.newInstance("8")
.addSizeDimension(0, 1)
.setLocation(Location.newInstance(16, 12))
.build();
VehicleRoutingProblem.Builder vrpBuilder = VehicleRoutingProblem.Builder.newInstance();
vrpBuilder
.addVehicle(vehicle)
// vrpBuilder.addJob(shipment1).addJob(shipment2).addJob(shipment3).addJob(shipment4)
.addJob(delivery1)
.addJob(delivery2)
.addJob(delivery3)
.addJob(delivery4)
.build();
VehicleRoutingProblem vrp = vrpBuilder.build();
final StateManager stateManager = new StateManager(vrp);
ConstraintManager constraintManager = new ConstraintManager(vrp, stateManager);
constraintManager.addLoadConstraint();
constraintManager.addTimeWindowConstraint();
VehicleFleetManager fleetManager =
new InfiniteFleetManagerFactory(vrp.getVehicles()).createFleetManager();
BestInsertionBuilder bestIBuilder =
new BestInsertionBuilder(vrp, fleetManager, stateManager, constraintManager);
bestIBuilder.setRouteLevel(2, 2);
@SuppressWarnings("unused")
InsertionStrategy bestInsertion = bestIBuilder.build();
assertTrue(true);
}