@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);
  }
Пример #3
0
  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;
 }
Пример #6
0
 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;
 }
Пример #7
0
 private double c(TourActivity from, TourActivity to, Vehicle vehicle) {
   return vrp.getTransportCosts()
       .getTransportCost(
           from.getLocation(),
           to.getLocation(),
           from.getEndTime(),
           DriverImpl.noDriver(),
           vehicle);
 }
Пример #8
0
 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;
 }
Пример #11
0
  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()));
  }
Пример #12
0
  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);
  }