trans/graphhopper-jsprit
1
0
Fork 0
mirror of https://github.com/graphhopper/jsprit.git synced 2020-01-24 07:45:05 +01:00
Code Issues Releases Wiki Activity

added indeces to main elements

Browse source
This commit is contained in:
oblonski 2014-07-15 10:59:18 +02:00
parent f9bad784ff
commit 8a5c1cceed
14 changed files with 241 additions and 1298 deletions
Download patch file Download diff file Expand all files Collapse all files

50
jsprit-core/src/main/java/jsprit/core/algorithm/io/VehicleRoutingAlgorithms.java
View file

@ -17,39 +17,10 @@
package jsprit.core.algorithm.io; package jsprit.core.algorithm.io;
import java.lang.Thread.UncaughtExceptionHandler; import jsprit.core.algorithm.*;
import java.net.URL;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import jsprit.core.algorithm.InsertionInitialSolutionFactory;
import jsprit.core.algorithm.RemoveEmptyVehicles;
import jsprit.core.algorithm.ResetAndIniFleetManager;
import jsprit.core.algorithm.SearchStrategy;
import jsprit.core.algorithm.SearchStrategy.DiscoveredSolution; import jsprit.core.algorithm.SearchStrategy.DiscoveredSolution;
import jsprit.core.algorithm.SearchStrategyManager; import jsprit.core.algorithm.acceptor.*;
import jsprit.core.algorithm.SearchStrategyModule; import jsprit.core.algorithm.io.VehicleRoutingAlgorithms.TypedMap.*;
import jsprit.core.algorithm.VehicleRoutingAlgorithm;
import jsprit.core.algorithm.acceptor.AcceptNewRemoveFirst;
import jsprit.core.algorithm.acceptor.ExperimentalSchrimpfAcceptance;
import jsprit.core.algorithm.acceptor.GreedyAcceptance;
import jsprit.core.algorithm.acceptor.GreedyAcceptance_minVehFirst;
import jsprit.core.algorithm.acceptor.SchrimpfAcceptance;
import jsprit.core.algorithm.acceptor.SchrimpfInitialThresholdGenerator;
import jsprit.core.algorithm.acceptor.SolutionAcceptor;
import jsprit.core.algorithm.io.VehicleRoutingAlgorithms.TypedMap.AbstractKey;
import jsprit.core.algorithm.io.VehicleRoutingAlgorithms.TypedMap.AcceptorKey;
import jsprit.core.algorithm.io.VehicleRoutingAlgorithms.TypedMap.InsertionStrategyKey;
import jsprit.core.algorithm.io.VehicleRoutingAlgorithms.TypedMap.RuinStrategyKey;
import jsprit.core.algorithm.io.VehicleRoutingAlgorithms.TypedMap.SelectorKey;
import jsprit.core.algorithm.io.VehicleRoutingAlgorithms.TypedMap.StrategyModuleKey;
import jsprit.core.algorithm.listener.AlgorithmEndsListener; import jsprit.core.algorithm.listener.AlgorithmEndsListener;
import jsprit.core.algorithm.listener.AlgorithmStartsListener; import jsprit.core.algorithm.listener.AlgorithmStartsListener;
import jsprit.core.algorithm.listener.VehicleRoutingAlgorithmListeners.PrioritizedVRAListener; import jsprit.core.algorithm.listener.VehicleRoutingAlgorithmListeners.PrioritizedVRAListener;
@ -66,11 +37,7 @@ import jsprit.core.algorithm.ruin.distance.JobDistance;
import jsprit.core.algorithm.selector.SelectBest; import jsprit.core.algorithm.selector.SelectBest;
import jsprit.core.algorithm.selector.SelectRandomly; import jsprit.core.algorithm.selector.SelectRandomly;
import jsprit.core.algorithm.selector.SolutionSelector; import jsprit.core.algorithm.selector.SolutionSelector;
import jsprit.core.algorithm.state.StateManager; import jsprit.core.algorithm.state.*;
import jsprit.core.algorithm.state.StateUpdater;
import jsprit.core.algorithm.state.UpdateActivityTimes;
import jsprit.core.algorithm.state.UpdateEndLocationIfRouteIsOpen;
import jsprit.core.algorithm.state.UpdateVariableCosts;
import jsprit.core.algorithm.termination.IterationWithoutImprovementTermination; import jsprit.core.algorithm.termination.IterationWithoutImprovementTermination;
import jsprit.core.algorithm.termination.PrematureAlgorithmTermination; import jsprit.core.algorithm.termination.PrematureAlgorithmTermination;
import jsprit.core.algorithm.termination.TimeTermination; import jsprit.core.algorithm.termination.TimeTermination;
@ -89,11 +56,16 @@ import jsprit.core.problem.vehicle.FiniteFleetManagerFactory;
import jsprit.core.problem.vehicle.InfiniteFleetManagerFactory; import jsprit.core.problem.vehicle.InfiniteFleetManagerFactory;
import jsprit.core.problem.vehicle.Vehicle; import jsprit.core.problem.vehicle.Vehicle;
import jsprit.core.problem.vehicle.VehicleFleetManager; import jsprit.core.problem.vehicle.VehicleFleetManager;
import org.apache.commons.configuration.HierarchicalConfiguration; import org.apache.commons.configuration.HierarchicalConfiguration;
import org.apache.commons.configuration.XMLConfiguration; import org.apache.commons.configuration.XMLConfiguration;
import org.apache.log4j.Logger; import org.apache.log4j.Logger;
import java.lang.Thread.UncaughtExceptionHandler;
import java.net.URL;
import java.util.*;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class VehicleRoutingAlgorithms { public class VehicleRoutingAlgorithms {
static class TypedMap { static class TypedMap {
@ -485,7 +457,7 @@ public class VehicleRoutingAlgorithms {
stateManager = stateMan; stateManager = stateMan;
} }
else{ else{
stateManager = new StateManager(vrp.getTransportCosts()); stateManager = new StateManager(vrp);
} }
stateManager.updateLoadStates(); stateManager.updateLoadStates();
stateManager.updateTimeWindowStates(); stateManager.updateTimeWindowStates();

6
jsprit-core/src/main/java/jsprit/core/algorithm/state/StateManager.java
View file

@ -454,9 +454,9 @@ public class StateManager implements RouteAndActivityStateGetter, IterationStart
UpdateLoads updateLoads = new UpdateLoads(this); UpdateLoads updateLoads = new UpdateLoads(this);
addActivityVisitor(updateLoads); addActivityVisitor(updateLoads);
addListener(updateLoads); addListener(updateLoads);
// addActivityVisitor(new UpdateMaxCapacityUtilisationAtActivitiesByLookingBackwardInRoute(this)); addActivityVisitor(new UpdateMaxCapacityUtilisationAtActivitiesByLookingBackwardInRoute(this));
// addActivityVisitor(new UpdateMaxCapacityUtilisationAtActivitiesByLookingForwardInRoute(this)); addActivityVisitor(new UpdateMaxCapacityUtilisationAtActivitiesByLookingForwardInRoute(this));
// addActivityVisitor(new UpdateMaxCapacityUtilisationAtRoute(this)); addActivityVisitor(new UpdateMaxCapacityUtilisationAtRoute(this));
} }
} }

25
jsprit-core/src/test/java/jsprit/core/algorithm/recreate/ShipmentInsertionCalculatorTest.java
View file

@ -205,20 +205,20 @@ public class ShipmentInsertionCalculatorTest {
Shipment shipment2 = Shipment.Builder.newInstance("s2").addSizeDimension(0, 1).setPickupLocation("10,10").setDeliveryLocation("0,0").build(); Shipment shipment2 = Shipment.Builder.newInstance("s2").addSizeDimension(0, 1).setPickupLocation("10,10").setDeliveryLocation("0,0").build();
Shipment shipment3 = Shipment.Builder.newInstance("s3").addSizeDimension(0, 1).setPickupLocation("0,0").setDeliveryLocation("9,9").build(); Shipment shipment3 = Shipment.Builder.newInstance("s3").addSizeDimension(0, 1).setPickupLocation("0,0").setDeliveryLocation("9,9").build();
when(vehicleRoutingProblem.copyAndGetActivities(shipment)).thenReturn(getTourActivities(shipment)); VehicleRoutingProblem.Builder vrpBuilder = VehicleRoutingProblem.Builder.newInstance();
when(vehicleRoutingProblem.copyAndGetActivities(shipment2)).thenReturn(getTourActivities(shipment2)); VehicleRoutingProblem vrp = vrpBuilder.addJob(shipment).addJob(shipment2).addJob(shipment3).build();
VehicleRoute route = VehicleRoute.emptyRoute(); VehicleRoute route = VehicleRoute.emptyRoute();
route.setVehicleAndDepartureTime(vehicle, 0.0); route.setVehicleAndDepartureTime(vehicle, 0.0);
Inserter inserter = new Inserter(new InsertionListeners(), vehicleRoutingProblem); Inserter inserter = new Inserter(new InsertionListeners(), vrp);
inserter.insertJob(shipment, new InsertionData(0,0,0,vehicle,null), route); inserter.insertJob(shipment, new InsertionData(0,0,0,vehicle,null), route);
inserter.insertJob(shipment2, new InsertionData(0,1,2,vehicle,null), route); inserter.insertJob(shipment2, new InsertionData(0,1,2,vehicle,null), route);
VehicleRoutingProblem vrp = mock(VehicleRoutingProblem.class); // VehicleRoutingProblem vrp = mock(VehicleRoutingProblem.class);
StateManager stateManager = new StateManager(vrp.getTransportCosts()); StateManager stateManager = new StateManager(vrp);
stateManager.updateLoadStates(); stateManager.updateLoadStates();
stateManager.informInsertionStarts(Arrays.asList(route), null); stateManager.informInsertionStarts(Arrays.asList(route), null);
@ -239,17 +239,18 @@ public class ShipmentInsertionCalculatorTest {
public void whenInsertingServiceWhileNoCapIsAvailable_itMustReturnNoInsertionData(){ public void whenInsertingServiceWhileNoCapIsAvailable_itMustReturnNoInsertionData(){
Shipment shipment = Shipment.Builder.newInstance("s").addSizeDimension(0, 1).setPickupLocation("0,10").setDeliveryLocation("0,0").build(); Shipment shipment = Shipment.Builder.newInstance("s").addSizeDimension(0, 1).setPickupLocation("0,10").setDeliveryLocation("0,0").build();
Shipment shipment2 = Shipment.Builder.newInstance("s2").addSizeDimension(0, 1).setPickupLocation("10,10").setDeliveryLocation("0,0").build(); Shipment shipment2 = Shipment.Builder.newInstance("s2").addSizeDimension(0, 1).setPickupLocation("10,10").setDeliveryLocation("0,0").build();
VehicleRoute route = VehicleRoute.emptyRoute();
VehicleRoutingProblem.Builder vrpBuilder = VehicleRoutingProblem.Builder.newInstance();
VehicleRoutingProblem vrp = vrpBuilder.addJob(shipment).addJob(shipment2).build();
VehicleRoute route = VehicleRoute.emptyRoute();
route.setVehicleAndDepartureTime(vehicle, 0.0); route.setVehicleAndDepartureTime(vehicle, 0.0);
when(vehicleRoutingProblem.copyAndGetActivities(shipment)).thenReturn(getTourActivities(shipment));
when(vehicleRoutingProblem.copyAndGetActivities(shipment2)).thenReturn(getTourActivities(shipment2)); Inserter inserter = new Inserter(new InsertionListeners(), vrp);
Inserter inserter = new Inserter(new InsertionListeners(), vehicleRoutingProblem);
inserter.insertJob(shipment, new InsertionData(0,0,0,vehicle,null), route); inserter.insertJob(shipment, new InsertionData(0,0,0,vehicle,null), route);
inserter.insertJob(shipment2, new InsertionData(0,1,2,vehicle,null), route); inserter.insertJob(shipment2, new InsertionData(0,1,2,vehicle,null), route);
VehicleRoutingProblem vrp = mock(VehicleRoutingProblem.class);
StateManager stateManager = new StateManager(vrp.getTransportCosts()); StateManager stateManager = new StateManager(vrp.getTransportCosts());
stateManager.updateLoadStates(); stateManager.updateLoadStates();
stateManager.informInsertionStarts(Arrays.asList(route), null); stateManager.informInsertionStarts(Arrays.asList(route), null);

17
jsprit-core/src/test/java/jsprit/core/algorithm/recreate/TestRouteLevelActivityInsertionCostEstimator.java
View file

@ -20,6 +20,9 @@ package jsprit.core.algorithm.recreate;
import jsprit.core.algorithm.state.StateManager; import jsprit.core.algorithm.state.StateManager;
import jsprit.core.algorithm.state.UpdateVariableCosts; import jsprit.core.algorithm.state.UpdateVariableCosts;
import jsprit.core.problem.AbstractActivity;
import jsprit.core.problem.JobActivityFactory;
import jsprit.core.problem.VehicleRoutingProblem;
import jsprit.core.problem.cost.VehicleRoutingActivityCosts; import jsprit.core.problem.cost.VehicleRoutingActivityCosts;
import jsprit.core.problem.cost.VehicleRoutingTransportCosts; import jsprit.core.problem.cost.VehicleRoutingTransportCosts;
import jsprit.core.problem.driver.Driver; import jsprit.core.problem.driver.Driver;
@ -41,11 +44,12 @@ import org.junit.Test;
import java.util.Arrays; import java.util.Arrays;
import java.util.Collections; import java.util.Collections;
import java.util.List;
import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertEquals;
/** /**
* Created by schroeder on 02.07.14. * unit tests to test route level insertion
*/ */
public class TestRouteLevelActivityInsertionCostEstimator { public class TestRouteLevelActivityInsertionCostEstimator {
@ -76,7 +80,16 @@ public class TestRouteLevelActivityInsertionCostEstimator {
VehicleType type = VehicleTypeImpl.Builder.newInstance("type").build(); VehicleType type = VehicleTypeImpl.Builder.newInstance("type").build();
Vehicle vehicle = VehicleImpl.Builder.newInstance("vehicle").setStartLocationId("0,0").setType(type).build(); Vehicle vehicle = VehicleImpl.Builder.newInstance("vehicle").setStartLocationId("0,0").setType(type).build();
route = VehicleRoute.Builder.newInstance(vehicle).addService(s1).addService(s2).addService(s3).build(); VehicleRoutingProblem.Builder vrpBuilder = VehicleRoutingProblem.Builder.newInstance();
final VehicleRoutingProblem vrp = vrpBuilder.addJob(s1).addJob(s2).addJob(s3).build();
route = VehicleRoute.Builder.newInstance(vehicle).setJobActivityFactory(new JobActivityFactory() {
@Override
public List<AbstractActivity> createActivity(Job job) {
return vrp.copyAndGetActivities(job);
}
}).addService(s1).addService(s2).addService(s3).build();
stateManager = new StateManager(routingCosts); stateManager = new StateManager(routingCosts);
stateManager.addStateUpdater(new UpdateVariableCosts(activityCosts,routingCosts,stateManager)); stateManager.addStateUpdater(new UpdateVariableCosts(activityCosts,routingCosts,stateManager));

70
jsprit-core/src/test/java/jsprit/core/algorithm/state/LoadStateTest.java
View file

@ -47,15 +47,17 @@ public class LoadStateTest {
serviceProblemBuilder.addJob(s1).addJob(s2); serviceProblemBuilder.addJob(s1).addJob(s2);
final VehicleRoutingProblem serviceProblem = serviceProblemBuilder.build(); final VehicleRoutingProblem serviceProblem = serviceProblemBuilder.build();
Pickup pickup = mock(Pickup.class); final VehicleRoutingProblem.Builder pdProblemBuilder = VehicleRoutingProblem.Builder.newInstance();
when(pickup.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0, 10).build()); Pickup pickup = (Pickup) Pickup.Builder.newInstance("pick").addSizeDimension(0,10).setLocationId("loc").build();
Delivery delivery = mock(Delivery.class); Delivery delivery = (Delivery) Delivery.Builder.newInstance("del").addSizeDimension(0,5).setLocationId("loc").build();
when(delivery.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0,5).build()); pdProblemBuilder.addJob(pickup).addJob(delivery);
final VehicleRoutingProblem pdProblem = pdProblemBuilder.build();
Shipment shipment1 = mock(Shipment.class); final VehicleRoutingProblem.Builder shipmentProblemBuilder = VehicleRoutingProblem.Builder.newInstance();
when(shipment1.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0, 10).build()); Shipment shipment1 = Shipment.Builder.newInstance("s1").addSizeDimension(0,10).setPickupLocation("pick").setDeliveryLocation("del").build();
Shipment shipment2 = mock(Shipment.class); Shipment shipment2 = Shipment.Builder.newInstance("s2").addSizeDimension(0,5).setPickupLocation("pick").setDeliveryLocation("del").build();
when(shipment2.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0, 5).build()); shipmentProblemBuilder.addJob(shipment1).addJob(shipment2).build();
final VehicleRoutingProblem shipmentProblem = shipmentProblemBuilder.build();
VehicleRoute.Builder serviceRouteBuilder = VehicleRoute.Builder.newInstance(vehicle); VehicleRoute.Builder serviceRouteBuilder = VehicleRoute.Builder.newInstance(vehicle);
serviceRouteBuilder.setJobActivityFactory(new JobActivityFactory() { serviceRouteBuilder.setJobActivityFactory(new JobActivityFactory() {
@ -67,61 +69,83 @@ public class LoadStateTest {
}); });
serviceRoute = serviceRouteBuilder.addService(s1).addService(s2).build(); serviceRoute = serviceRouteBuilder.addService(s1).addService(s2).build();
pickup_delivery_route = VehicleRoute.Builder.newInstance(vehicle).addService(pickup).addService(delivery).build();
shipment_route = VehicleRoute.Builder.newInstance(vehicle).addPickup(shipment1).addPickup(shipment2).addDelivery(shipment2).addDelivery(shipment1).build(); VehicleRoute.Builder pdRouteBuilder = VehicleRoute.Builder.newInstance(vehicle);
pdRouteBuilder.setJobActivityFactory(new JobActivityFactory() {
@Override
public List<AbstractActivity> createActivity(Job job) {
return pdProblem.copyAndGetActivities(job);
}
});
pickup_delivery_route = pdRouteBuilder.addService(pickup).addService(delivery).build();
VehicleRoute.Builder shipmentRouteBuilder = VehicleRoute.Builder.newInstance(vehicle);
shipmentRouteBuilder.setJobActivityFactory(new JobActivityFactory() {
@Override
public List<AbstractActivity> createActivity(Job job) {
return shipmentProblem.copyAndGetActivities(job);
}
});
shipment_route = shipmentRouteBuilder.addPickup(shipment1).addPickup(shipment2).addDelivery(shipment2).addDelivery(shipment1).build();
stateManager = new StateManager(mock(VehicleRoutingTransportCosts.class)); stateManager = new StateManager(mock(VehicleRoutingTransportCosts.class));
stateManager.updateLoadStates(); stateManager.updateLoadStates();
stateManager.informInsertionStarts(Arrays.asList(serviceRoute), Collections.<Job>emptyList());
// <stateManager.informInsertionStarts(Arrays.asList(serviceRoute,pickup_delivery_route,shipment_route), Collections.<Job>emptyList());
} }
@Test @Test
public void loadAtEndShouldBe15(){ public void loadAtEndShouldBe15(){
stateManager.informInsertionStarts(Arrays.asList(serviceRoute), Collections.<Job>emptyList());
Capacity routeState = stateManager.getRouteState(serviceRoute, StateFactory.LOAD_AT_END, Capacity.class); Capacity routeState = stateManager.getRouteState(serviceRoute, StateFactory.LOAD_AT_END, Capacity.class);
assertEquals(15,routeState.get(0)); assertEquals(15,routeState.get(0));
} }
@Test @Test
public void loadAtBeginningShouldBe0(){ public void loadAtBeginningShouldBe0(){
stateManager.informInsertionStarts(Arrays.asList(serviceRoute), Collections.<Job>emptyList());
Capacity routeState = stateManager.getRouteState(serviceRoute, StateFactory.LOAD_AT_BEGINNING, Capacity.class); Capacity routeState = stateManager.getRouteState(serviceRoute, StateFactory.LOAD_AT_BEGINNING, Capacity.class);
assertEquals(0,routeState.get(0)); assertEquals(0,routeState.get(0));
} }
@Test @Test
public void loadAtAct1ShouldBe10(){ public void loadAtAct1ShouldBe10(){
stateManager.informInsertionStarts(Arrays.asList(serviceRoute), Collections.<Job>emptyList());
Capacity atAct1 = stateManager.getActivityState(serviceRoute.getActivities().get(0), StateFactory.LOAD, Capacity.class); Capacity atAct1 = stateManager.getActivityState(serviceRoute.getActivities().get(0), StateFactory.LOAD, Capacity.class);
assertEquals(10,atAct1.get(0)); assertEquals(10,atAct1.get(0));
} }
@Test @Test
public void loadAtAct2ShouldBe15(){ public void loadAtAct2ShouldBe15(){
stateManager.informInsertionStarts(Arrays.asList(serviceRoute), Collections.<Job>emptyList());
Capacity atAct2 = stateManager.getActivityState(serviceRoute.getActivities().get(1), StateFactory.LOAD, Capacity.class); Capacity atAct2 = stateManager.getActivityState(serviceRoute.getActivities().get(1), StateFactory.LOAD, Capacity.class);
assertEquals(15,atAct2.get(0)); assertEquals(15,atAct2.get(0));
} }
@Test @Test
public void futureMaxLoatAtAct1ShouldBe15(){ public void futureMaxLoatAtAct1ShouldBe15(){
stateManager.informInsertionStarts(Arrays.asList(serviceRoute), Collections.<Job>emptyList());
Capacity atAct1 = stateManager.getActivityState(serviceRoute.getActivities().get(0), StateFactory.FUTURE_MAXLOAD, Capacity.class); Capacity atAct1 = stateManager.getActivityState(serviceRoute.getActivities().get(0), StateFactory.FUTURE_MAXLOAD, Capacity.class);
assertEquals(15,atAct1.get(0)); assertEquals(15,atAct1.get(0));
} }
@Test @Test
public void futureMaxLoatAtAct2ShouldBe15(){ public void futureMaxLoatAtAct2ShouldBe15(){
stateManager.informInsertionStarts(Arrays.asList(serviceRoute), Collections.<Job>emptyList());
Capacity atAct2 = stateManager.getActivityState(serviceRoute.getActivities().get(1), StateFactory.FUTURE_MAXLOAD, Capacity.class); Capacity atAct2 = stateManager.getActivityState(serviceRoute.getActivities().get(1), StateFactory.FUTURE_MAXLOAD, Capacity.class);
assertEquals(15,atAct2.get(0)); assertEquals(15,atAct2.get(0));
} }
@Test @Test
public void pastMaxLoatAtAct1ShouldBe0(){ public void pastMaxLoatAtAct1ShouldBe0(){
stateManager.informInsertionStarts(Arrays.asList(serviceRoute), Collections.<Job>emptyList());
Capacity atAct1 = stateManager.getActivityState(serviceRoute.getActivities().get(0), StateFactory.PAST_MAXLOAD, Capacity.class); Capacity atAct1 = stateManager.getActivityState(serviceRoute.getActivities().get(0), StateFactory.PAST_MAXLOAD, Capacity.class);
assertEquals(10,atAct1.get(0)); assertEquals(10,atAct1.get(0));
} }
@Test @Test
public void pastMaxLoatAtAct2ShouldBe10(){ public void pastMaxLoatAtAct2ShouldBe10(){
stateManager.informInsertionStarts(Arrays.asList(serviceRoute), Collections.<Job>emptyList());
Capacity atAct2 = stateManager.getActivityState(serviceRoute.getActivities().get(1), StateFactory.PAST_MAXLOAD, Capacity.class); Capacity atAct2 = stateManager.getActivityState(serviceRoute.getActivities().get(1), StateFactory.PAST_MAXLOAD, Capacity.class);
assertEquals(15,atAct2.get(0)); assertEquals(15,atAct2.get(0));
} }
@ -132,48 +156,56 @@ public class LoadStateTest {
*/ */
@Test @Test
public void when_pdroute_loadAtEndShouldBe10(){ public void when_pdroute_loadAtEndShouldBe10(){
stateManager.informInsertionStarts(Arrays.asList(pickup_delivery_route), Collections.<Job>emptyList());
Capacity routeState = stateManager.getRouteState(pickup_delivery_route, StateFactory.LOAD_AT_END, Capacity.class); Capacity routeState = stateManager.getRouteState(pickup_delivery_route, StateFactory.LOAD_AT_END, Capacity.class);
assertEquals(10,routeState.get(0)); assertEquals(10,routeState.get(0));
} }
@Test @Test
public void when_pdroute_loadAtBeginningShouldBe5(){ public void when_pdroute_loadAtBeginningShouldBe5(){
stateManager.informInsertionStarts(Arrays.asList(pickup_delivery_route), Collections.<Job>emptyList());
Capacity routeState = stateManager.getRouteState(pickup_delivery_route, StateFactory.LOAD_AT_BEGINNING, Capacity.class); Capacity routeState = stateManager.getRouteState(pickup_delivery_route, StateFactory.LOAD_AT_BEGINNING, Capacity.class);
assertEquals(5,routeState.get(0)); assertEquals(5,routeState.get(0));
} }
@Test @Test
public void when_pdroute_loadAtAct1ShouldBe15(){ public void when_pdroute_loadAtAct1ShouldBe15(){
stateManager.informInsertionStarts(Arrays.asList(pickup_delivery_route), Collections.<Job>emptyList());
Capacity atAct1 = stateManager.getActivityState(pickup_delivery_route.getActivities().get(0), StateFactory.LOAD, Capacity.class); Capacity atAct1 = stateManager.getActivityState(pickup_delivery_route.getActivities().get(0), StateFactory.LOAD, Capacity.class);
assertEquals(15,atAct1.get(0)); assertEquals(15,atAct1.get(0));
} }
@Test @Test
public void when_pdroute_loadAtAct2ShouldBe10(){ public void when_pdroute_loadAtAct2ShouldBe10(){
stateManager.informInsertionStarts(Arrays.asList(pickup_delivery_route), Collections.<Job>emptyList());
Capacity atAct2 = stateManager.getActivityState(pickup_delivery_route.getActivities().get(1), StateFactory.LOAD, Capacity.class); Capacity atAct2 = stateManager.getActivityState(pickup_delivery_route.getActivities().get(1), StateFactory.LOAD, Capacity.class);
assertEquals(10,atAct2.get(0)); assertEquals(10,atAct2.get(0));
} }
@Test @Test
public void when_pdroute_futureMaxLoatAtAct1ShouldBe15(){ public void when_pdroute_futureMaxLoatAtAct1ShouldBe15(){
stateManager.informInsertionStarts(Arrays.asList(pickup_delivery_route), Collections.<Job>emptyList());
Capacity atAct1 = stateManager.getActivityState(pickup_delivery_route.getActivities().get(0), StateFactory.FUTURE_MAXLOAD, Capacity.class); Capacity atAct1 = stateManager.getActivityState(pickup_delivery_route.getActivities().get(0), StateFactory.FUTURE_MAXLOAD, Capacity.class);
assertEquals(15,atAct1.get(0)); assertEquals(15,atAct1.get(0));
} }
@Test @Test
public void when_pdroute_futureMaxLoatAtAct2ShouldBe10(){ public void when_pdroute_futureMaxLoatAtAct2ShouldBe10(){
stateManager.informInsertionStarts(Arrays.asList(pickup_delivery_route), Collections.<Job>emptyList());
Capacity atAct2 = stateManager.getActivityState(pickup_delivery_route.getActivities().get(1), StateFactory.FUTURE_MAXLOAD, Capacity.class); Capacity atAct2 = stateManager.getActivityState(pickup_delivery_route.getActivities().get(1), StateFactory.FUTURE_MAXLOAD, Capacity.class);
assertEquals(10,atAct2.get(0)); assertEquals(10,atAct2.get(0));
} }
@Test @Test
public void when_pdroute_pastMaxLoatAtAct1ShouldBe15(){ public void when_pdroute_pastMaxLoatAtAct1ShouldBe15(){
stateManager.informInsertionStarts(Arrays.asList(pickup_delivery_route), Collections.<Job>emptyList());
Capacity atAct1 = stateManager.getActivityState(pickup_delivery_route.getActivities().get(0), StateFactory.PAST_MAXLOAD, Capacity.class); Capacity atAct1 = stateManager.getActivityState(pickup_delivery_route.getActivities().get(0), StateFactory.PAST_MAXLOAD, Capacity.class);
assertEquals(15,atAct1.get(0)); assertEquals(15,atAct1.get(0));
} }
@Test @Test
public void when_pdroute_pastMaxLoatAtAct2ShouldBe10(){ public void when_pdroute_pastMaxLoatAtAct2ShouldBe10(){
stateManager.informInsertionStarts(Arrays.asList(pickup_delivery_route), Collections.<Job>emptyList());
Capacity atAct2 = stateManager.getActivityState(pickup_delivery_route.getActivities().get(1), StateFactory.PAST_MAXLOAD, Capacity.class); Capacity atAct2 = stateManager.getActivityState(pickup_delivery_route.getActivities().get(1), StateFactory.PAST_MAXLOAD, Capacity.class);
assertEquals(15,atAct2.get(0)); assertEquals(15,atAct2.get(0));
} }
@ -187,84 +219,98 @@ public class LoadStateTest {
*/ */
@Test @Test
public void when_shipmentroute_loadAtEndShouldBe0(){ public void when_shipmentroute_loadAtEndShouldBe0(){
stateManager.informInsertionStarts(Arrays.asList(shipment_route), Collections.<Job>emptyList());
Capacity routeState = stateManager.getRouteState(shipment_route, StateFactory.LOAD_AT_END, Capacity.class); Capacity routeState = stateManager.getRouteState(shipment_route, StateFactory.LOAD_AT_END, Capacity.class);
assertEquals(0,routeState.get(0)); assertEquals(0,routeState.get(0));
} }
@Test @Test
public void when_shipmentroute_loadAtBeginningShouldBe0(){ public void when_shipmentroute_loadAtBeginningShouldBe0(){
stateManager.informInsertionStarts(Arrays.asList(shipment_route), Collections.<Job>emptyList());
Capacity routeState = stateManager.getRouteState(shipment_route, StateFactory.LOAD_AT_BEGINNING, Capacity.class); Capacity routeState = stateManager.getRouteState(shipment_route, StateFactory.LOAD_AT_BEGINNING, Capacity.class);
assertEquals(0,routeState.get(0)); assertEquals(0,routeState.get(0));
} }
@Test @Test
public void when_shipmentroute_loadAtAct1ShouldBe10(){ public void when_shipmentroute_loadAtAct1ShouldBe10(){
stateManager.informInsertionStarts(Arrays.asList(shipment_route), Collections.<Job>emptyList());
Capacity atAct1 = stateManager.getActivityState(shipment_route.getActivities().get(0), StateFactory.LOAD, Capacity.class); Capacity atAct1 = stateManager.getActivityState(shipment_route.getActivities().get(0), StateFactory.LOAD, Capacity.class);
assertEquals(10,atAct1.get(0)); assertEquals(10,atAct1.get(0));
} }
@Test @Test
public void when_shipmentroute_loadAtAct2ShouldBe15(){ public void when_shipmentroute_loadAtAct2ShouldBe15(){
stateManager.informInsertionStarts(Arrays.asList(shipment_route), Collections.<Job>emptyList());
Capacity atAct2 = stateManager.getActivityState(shipment_route.getActivities().get(1), StateFactory.LOAD, Capacity.class); Capacity atAct2 = stateManager.getActivityState(shipment_route.getActivities().get(1), StateFactory.LOAD, Capacity.class);
assertEquals(15,atAct2.get(0)); assertEquals(15,atAct2.get(0));
} }
@Test @Test
public void when_shipmentroute_loadAtAct3ShouldBe10(){ public void when_shipmentroute_loadAtAct3ShouldBe10(){
stateManager.informInsertionStarts(Arrays.asList(shipment_route), Collections.<Job>emptyList());
Capacity atAct = stateManager.getActivityState(shipment_route.getActivities().get(2), StateFactory.LOAD, Capacity.class); Capacity atAct = stateManager.getActivityState(shipment_route.getActivities().get(2), StateFactory.LOAD, Capacity.class);
assertEquals(10, atAct.get(0)); assertEquals(10, atAct.get(0));
} }
@Test @Test
public void when_shipmentroute_loadAtAct4ShouldBe0(){ public void when_shipmentroute_loadAtAct4ShouldBe0(){
stateManager.informInsertionStarts(Arrays.asList(shipment_route), Collections.<Job>emptyList());
Capacity atAct = stateManager.getActivityState(shipment_route.getActivities().get(3), StateFactory.LOAD, Capacity.class); Capacity atAct = stateManager.getActivityState(shipment_route.getActivities().get(3), StateFactory.LOAD, Capacity.class);
assertEquals(0, atAct.get(0)); assertEquals(0, atAct.get(0));
} }
@Test @Test
public void when_shipmentroute_futureMaxLoatAtAct1ShouldBe15(){ public void when_shipmentroute_futureMaxLoatAtAct1ShouldBe15(){
stateManager.informInsertionStarts(Arrays.asList(shipment_route), Collections.<Job>emptyList());
Capacity atAct1 = stateManager.getActivityState(shipment_route.getActivities().get(0), StateFactory.FUTURE_MAXLOAD, Capacity.class); Capacity atAct1 = stateManager.getActivityState(shipment_route.getActivities().get(0), StateFactory.FUTURE_MAXLOAD, Capacity.class);
assertEquals(15,atAct1.get(0)); assertEquals(15,atAct1.get(0));
} }
@Test @Test
public void when_shipmentroute_futureMaxLoatAtAct2ShouldBe15(){ public void when_shipmentroute_futureMaxLoatAtAct2ShouldBe15(){
stateManager.informInsertionStarts(Arrays.asList(shipment_route), Collections.<Job>emptyList());
Capacity atAct2 = stateManager.getActivityState(shipment_route.getActivities().get(1), StateFactory.FUTURE_MAXLOAD, Capacity.class); Capacity atAct2 = stateManager.getActivityState(shipment_route.getActivities().get(1), StateFactory.FUTURE_MAXLOAD, Capacity.class);
assertEquals(15,atAct2.get(0)); assertEquals(15,atAct2.get(0));
} }
@Test @Test
public void when_shipmentroute_futureMaxLoatAtAct3ShouldBe10(){ public void when_shipmentroute_futureMaxLoatAtAct3ShouldBe10(){
stateManager.informInsertionStarts(Arrays.asList(shipment_route), Collections.<Job>emptyList());
Capacity atAct = stateManager.getActivityState(shipment_route.getActivities().get(2), StateFactory.FUTURE_MAXLOAD, Capacity.class); Capacity atAct = stateManager.getActivityState(shipment_route.getActivities().get(2), StateFactory.FUTURE_MAXLOAD, Capacity.class);
assertEquals(10,atAct.get(0)); assertEquals(10,atAct.get(0));
} }
@Test @Test
public void when_shipmentroute_futureMaxLoatAtAct4ShouldBe0(){ public void when_shipmentroute_futureMaxLoatAtAct4ShouldBe0(){
stateManager.informInsertionStarts(Arrays.asList(shipment_route), Collections.<Job>emptyList());
Capacity atAct = stateManager.getActivityState(shipment_route.getActivities().get(3), StateFactory.FUTURE_MAXLOAD, Capacity.class); Capacity atAct = stateManager.getActivityState(shipment_route.getActivities().get(3), StateFactory.FUTURE_MAXLOAD, Capacity.class);
assertEquals(0,atAct.get(0)); assertEquals(0,atAct.get(0));
} }
@Test @Test
public void when_shipmentroute_pastMaxLoatAtAct1ShouldBe10(){ public void when_shipmentroute_pastMaxLoatAtAct1ShouldBe10(){
stateManager.informInsertionStarts(Arrays.asList(shipment_route), Collections.<Job>emptyList());
Capacity atAct1 = stateManager.getActivityState(shipment_route.getActivities().get(0), StateFactory.PAST_MAXLOAD, Capacity.class); Capacity atAct1 = stateManager.getActivityState(shipment_route.getActivities().get(0), StateFactory.PAST_MAXLOAD, Capacity.class);
assertEquals(10,atAct1.get(0)); assertEquals(10,atAct1.get(0));
} }
@Test @Test
public void when_shipmentroute_pastMaxLoatAtAct2ShouldBe10(){ public void when_shipmentroute_pastMaxLoatAtAct2ShouldBe10(){
stateManager.informInsertionStarts(Arrays.asList(shipment_route), Collections.<Job>emptyList());
Capacity atAct2 = stateManager.getActivityState(shipment_route.getActivities().get(1), StateFactory.PAST_MAXLOAD, Capacity.class); Capacity atAct2 = stateManager.getActivityState(shipment_route.getActivities().get(1), StateFactory.PAST_MAXLOAD, Capacity.class);
assertEquals(15,atAct2.get(0)); assertEquals(15,atAct2.get(0));
} }
@Test @Test
public void when_shipmentroute_pastMaxLoatAtAct3ShouldBe15(){ public void when_shipmentroute_pastMaxLoatAtAct3ShouldBe15(){
stateManager.informInsertionStarts(Arrays.asList(shipment_route), Collections.<Job>emptyList());
Capacity atAct = stateManager.getActivityState(shipment_route.getActivities().get(2), StateFactory.PAST_MAXLOAD, Capacity.class); Capacity atAct = stateManager.getActivityState(shipment_route.getActivities().get(2), StateFactory.PAST_MAXLOAD, Capacity.class);
assertEquals(15,atAct.get(0)); assertEquals(15,atAct.get(0));
} }
@Test @Test
public void when_shipmentroute_pastMaxLoatAtAct4ShouldBe15(){ public void when_shipmentroute_pastMaxLoatAtAct4ShouldBe15(){
stateManager.informInsertionStarts(Arrays.asList(shipment_route), Collections.<Job>emptyList());
Capacity atAct = stateManager.getActivityState(shipment_route.getActivities().get(3), StateFactory.PAST_MAXLOAD, Capacity.class); Capacity atAct = stateManager.getActivityState(shipment_route.getActivities().get(3), StateFactory.PAST_MAXLOAD, Capacity.class);
assertEquals(15,atAct.get(0)); assertEquals(15,atAct.get(0));
} }

12
jsprit-core/src/test/java/jsprit/core/algorithm/state/StateManagerTest.java
View file

@ -29,6 +29,7 @@ import org.junit.Test;
import static org.junit.Assert.*; import static org.junit.Assert.*;
import static org.mockito.Mockito.mock; import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
public class StateManagerTest { public class StateManagerTest {
@ -77,8 +78,9 @@ public class StateManagerTest {
@Test @Test
public void whenActivityStateIsSetWithGenericMethod_itMustBeSetCorrectly(){ public void whenActivityStateIsSetWithGenericMethod_itMustBeSetCorrectly(){
TourActivity activity = mock(TourActivity.class); TourActivity activity = mock(TourActivity.class);
when(activity.getIndex()).thenReturn(0);
StateManager stateManager = new StateManager(mock(VehicleRoutingTransportCosts.class)); StateManager stateManager = new StateManager(mock(VehicleRoutingTransportCosts.class));
StateId id = StateFactory.createId("myState"); StateId id = stateManager.createStateId("myState");
State state = StateFactory.createState(1.); State state = StateFactory.createState(1.);
stateManager.putTypedActivityState(activity, id, State.class, state); stateManager.putTypedActivityState(activity, id, State.class, state);
assertEquals(1.,stateManager.getActivityState(activity, id, State.class).toDouble(),0.01); assertEquals(1.,stateManager.getActivityState(activity, id, State.class).toDouble(),0.01);
@ -88,7 +90,7 @@ public class StateManagerTest {
public void whenActivityStateIsSetWithGenericMethodAndBoolean_itMustBeSetCorrectly(){ public void whenActivityStateIsSetWithGenericMethodAndBoolean_itMustBeSetCorrectly(){
TourActivity activity = mock(TourActivity.class); TourActivity activity = mock(TourActivity.class);
StateManager stateManager = new StateManager(mock(VehicleRoutingTransportCosts.class)); StateManager stateManager = new StateManager(mock(VehicleRoutingTransportCosts.class));
StateId id = StateFactory.createId("myState"); StateId id = stateManager.createStateId("myState");
boolean routeIsRed = true; boolean routeIsRed = true;
stateManager.putTypedActivityState(activity, id, Boolean.class, routeIsRed); stateManager.putTypedActivityState(activity, id, Boolean.class, routeIsRed);
assertTrue(stateManager.getActivityState(activity, id, Boolean.class)); assertTrue(stateManager.getActivityState(activity, id, Boolean.class));
@ -98,7 +100,7 @@ public class StateManagerTest {
public void whenActivityStateIsSetWithGenericMethodAndInteger_itMustBeSetCorrectly(){ public void whenActivityStateIsSetWithGenericMethodAndInteger_itMustBeSetCorrectly(){
TourActivity activity = mock(TourActivity.class); TourActivity activity = mock(TourActivity.class);
StateManager stateManager = new StateManager(mock(VehicleRoutingTransportCosts.class)); StateManager stateManager = new StateManager(mock(VehicleRoutingTransportCosts.class));
StateId id = StateFactory.createId("myState"); StateId id = stateManager.createStateId("myState");
int load = 3; int load = 3;
stateManager.putTypedActivityState(activity, id, Integer.class, load); stateManager.putTypedActivityState(activity, id, Integer.class, load);
int getLoad = stateManager.getActivityState(activity, id, Integer.class); int getLoad = stateManager.getActivityState(activity, id, Integer.class);
@ -109,7 +111,7 @@ public class StateManagerTest {
public void whenActivityStateIsSetWithGenericMethodAndCapacity_itMustBeSetCorrectly(){ public void whenActivityStateIsSetWithGenericMethodAndCapacity_itMustBeSetCorrectly(){
TourActivity activity = mock(TourActivity.class); TourActivity activity = mock(TourActivity.class);
StateManager stateManager = new StateManager(mock(VehicleRoutingTransportCosts.class)); StateManager stateManager = new StateManager(mock(VehicleRoutingTransportCosts.class));
StateId id = StateFactory.createId("myState"); StateId id = stateManager.createStateId("myState");
Capacity capacity = Capacity.Builder.newInstance().addDimension(0, 500).build(); Capacity capacity = Capacity.Builder.newInstance().addDimension(0, 500).build();
stateManager.putTypedActivityState(activity, id, Capacity.class, capacity); stateManager.putTypedActivityState(activity, id, Capacity.class, capacity);
Capacity getCap = stateManager.getActivityState(activity, id, Capacity.class); Capacity getCap = stateManager.getActivityState(activity, id, Capacity.class);
@ -119,7 +121,7 @@ public class StateManagerTest {
@Test @Test
public void whenProblemStateIsSet_itMustBeSetCorrectly(){ public void whenProblemStateIsSet_itMustBeSetCorrectly(){
StateManager stateManager = new StateManager(mock(VehicleRoutingTransportCosts.class)); StateManager stateManager = new StateManager(mock(VehicleRoutingTransportCosts.class));
StateId id = StateFactory.createId("problemState"); StateId id = stateManager.createStateId("problemState");
stateManager.putProblemState(id, Boolean.class, true); stateManager.putProblemState(id, Boolean.class, true);
boolean problemState = stateManager.getProblemState(id, Boolean.class); boolean problemState = stateManager.getProblemState(id, Boolean.class);
assertTrue(problemState); assertTrue(problemState);

172
jsprit-core/src/test/java/jsprit/core/algorithm/state/TestTourStateUpdaterWithService.java
View file

@ -1,172 +0,0 @@
/*******************************************************************************
* Copyright (C) 2013 Stefan Schroeder
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 3.0 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/
package jsprit.core.algorithm.state;
import static org.junit.Assert.assertEquals;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import jsprit.core.problem.Capacity;
import jsprit.core.problem.VehicleRoutingProblem;
import jsprit.core.problem.cost.VehicleRoutingTransportCosts;
import jsprit.core.problem.driver.Driver;
import jsprit.core.problem.driver.DriverImpl;
import jsprit.core.problem.job.Job;
import jsprit.core.problem.job.Service;
import jsprit.core.problem.solution.route.VehicleRoute;
import jsprit.core.problem.solution.route.activity.ServiceActivity;
import jsprit.core.problem.solution.route.activity.TimeWindow;
import jsprit.core.problem.solution.route.activity.TourActivities;
import jsprit.core.problem.solution.route.state.StateFactory;
import jsprit.core.problem.vehicle.Vehicle;
import jsprit.core.problem.vehicle.VehicleImpl;
import jsprit.core.problem.vehicle.VehicleTypeImpl;
import jsprit.core.util.CostFactory;
import org.junit.Before;
import org.junit.Test;
public class TestTourStateUpdaterWithService {
TourActivities tour;
Driver driver;
Vehicle vehicle;
TourActivities anotherTour;
StateManager states;
private VehicleRoute vehicleRoute;
private ServiceActivity act1;
private ServiceActivity act2;
@Before
public void setUp() {
VehicleRoutingTransportCosts cost = CostFactory.createManhattanCosts();
// VehicleRoutingTransportCosts cost = new VehicleRoutingTransportCosts() {
//
// @Override
// public double getBackwardTransportTime(String fromId, String toId,
// double arrivalTime, Driver driver, Vehicle vehicle) {
// return getTransportCost(fromId, toId, arrivalTime, driver, vehicle);
// }
//
// @Override
// public double getBackwardTransportCost(String fromId, String toId,
// double arrivalTime, Driver driver, Vehicle vehicle) {
// return getTransportCost(fromId, toId, arrivalTime, driver, vehicle);
// }
//
// @Override
// public double getTransportCost(String fromId, String toId, double departureTime, Driver driver, Vehicle vehicle) {
// String[] fromTokens = fromId.split(",");
// String[] toTokens = toId.split(",");
// double fromX = Double.parseDouble(fromTokens[0]);
// double fromY = Double.parseDouble(fromTokens[1]);
//
// double toX = Double.parseDouble(toTokens[0]);
// double toY = Double.parseDouble(toTokens[1]);
//
// return ManhattanDistanceCalculator.calculateDistance(new Coordinate(fromX, fromY), new Coordinate(toX, toY));
// }
//
// @Override
// public double getTransportTime(String fromId, String toId, double departureTime, Driver driver, Vehicle vehicle) {
// return getTransportCost(fromId, toId, departureTime, driver, vehicle);
// }
// };
Service firstService = Service.Builder.newInstance("1").addSizeDimension(0, 5).setLocationId("10,0").setTimeWindow(TimeWindow.newInstance(0, 20)).build();
Service secondService = Service.Builder.newInstance("2").addSizeDimension(0, 5).setLocationId("0,10").setTimeWindow(TimeWindow.newInstance(0, 50)).build();
Collection<Job> services = new ArrayList<Job>();
services.add(firstService);
services.add(secondService);
VehicleTypeImpl type = VehicleTypeImpl.Builder.newInstance("test").addCapacityDimension(0, 10).build();
vehicle = VehicleImpl.Builder.newInstance("testvehicle").setType(type).setStartLocationId("0,0")
.setEarliestStart(0.0).setLatestArrival(50.0).build();
VehicleRoutingProblem vrp = VehicleRoutingProblem.Builder.newInstance().addAllJobs(services).addVehicle(vehicle).setRoutingCost(cost).build();
states = new StateManager(vrp.getTransportCosts());
states.updateLoadStates();
states.updateTimeWindowStates();
states.addStateUpdater(new UpdateVariableCosts(vrp.getActivityCosts(), vrp.getTransportCosts(), states));
states.addStateUpdater(new UpdateActivityTimes(vrp.getTransportCosts()));
act1 = ServiceActivity.newInstance(firstService);
act2 = ServiceActivity.newInstance(secondService);
vehicleRoute = VehicleRoute.Builder.newInstance(vehicle, DriverImpl.noDriver()).build();//.newInstance(tour,DriverImpl.noDriver(),vehicle);
vehicleRoute.getTourActivities().addActivity(act1);
vehicleRoute.getTourActivities().addActivity(act2);
}
@Test
public void testCalculatedCost() {
states.informInsertionStarts(Arrays.asList(vehicleRoute), null);
assertEquals(40., states.getRouteState(vehicleRoute,StateFactory.COSTS, Double.class), 0.05);
assertEquals(10, states.getRouteState(vehicleRoute, StateFactory.LOAD_AT_END, Capacity.class).get(0));
}
@Test
public void testStatesOfAct0(){
states.informInsertionStarts(Arrays.asList(vehicleRoute), null);
assertEquals(0.0, vehicleRoute.getStart().getEndTime(),0.05);
assertEquals(vehicleRoute.getVehicle().getStartLocationId(), vehicleRoute.getStart().getLocationId());
assertEquals(vehicleRoute.getVehicle().getEarliestDeparture(), vehicleRoute.getStart().getTheoreticalEarliestOperationStartTime(),0.05);
assertEquals(Double.MAX_VALUE, vehicleRoute.getStart().getTheoreticalLatestOperationStartTime(),0.05);
}
@Test
public void testStatesOfAct1(){
states.informInsertionStarts(Arrays.asList(vehicleRoute), null);
assertEquals(10.0, states.getActivityState(act1, StateFactory.COSTS, Double.class),0.05);
assertEquals(5, states.getActivityState(act1, StateFactory.LOAD, Capacity.class).get(0),0.05);
assertEquals(20.0, states.getActivityState(act1, StateFactory.LATEST_OPERATION_START_TIME, Double.class),0.05);
}
@Test
public void testStatesOfAct2(){
states.informInsertionStarts(Arrays.asList(vehicleRoute), null);
assertEquals(30.0, states.getActivityState(act2, StateFactory.COSTS, Double.class),0.05);
assertEquals(10, states.getActivityState(act2, StateFactory.LOAD, Capacity.class).get(0),0.05);
assertEquals(40.0, states.getActivityState(act2, StateFactory.LATEST_OPERATION_START_TIME, Double.class),0.05);
}
@Test
public void testStatesOfAct3(){
states.informInsertionStarts(Arrays.asList(vehicleRoute), null);
assertEquals(40.0, states.getRouteState(vehicleRoute, StateFactory.COSTS, Double.class), 0.05);
assertEquals(40.0, vehicleRoute.getEnd().getArrTime(),0.05);
assertEquals(50.0, vehicleRoute.getEnd().getTheoreticalLatestOperationStartTime(),0.05);
}
}

408
jsprit-core/src/test/java/jsprit/core/algorithm/state/UpdateLoadsTest.java
View file

@ -1,408 +0,0 @@
/*******************************************************************************
* Copyright (c) 2014 Stefan Schroeder.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 3.0 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
*
* Contributors:
* Stefan Schroeder - initial API and implementation
******************************************************************************/
package jsprit.core.algorithm.state;
import static org.junit.Assert.assertEquals;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import java.util.Arrays;
import java.util.Collections;
import jsprit.core.problem.Capacity;
import jsprit.core.problem.cost.VehicleRoutingTransportCosts;
import jsprit.core.problem.driver.Driver;
import jsprit.core.problem.job.Delivery;
import jsprit.core.problem.job.Job;
import jsprit.core.problem.job.Pickup;
import jsprit.core.problem.job.Service;
import jsprit.core.problem.solution.route.RouteActivityVisitor;
import jsprit.core.problem.solution.route.VehicleRoute;
import jsprit.core.problem.solution.route.state.StateFactory;
import jsprit.core.problem.vehicle.Vehicle;
import jsprit.core.problem.vehicle.VehicleType;
import org.junit.Before;
import org.junit.Test;
public class UpdateLoadsTest {
private Vehicle vehicle;
@Before
public void doBefore(){
vehicle = mock(Vehicle.class);
VehicleType type = mock(VehicleType.class);
when(type.getCapacityDimensions()).thenReturn(Capacity.Builder.newInstance().addDimension(0, 10000)
.addDimension(1, 10000)
.addDimension(2, 10000)
.addDimension(3, 10000)
.addDimension(4, 10000)
.addDimension(5, 10000).build());
when(vehicle.getType()).thenReturn(type);
}
@Test
public void whenVehicleRouteIsEmpty_loadsAtBeginningAndEndShouldBeZero(){
StateManager stateManager = new StateManager(mock(VehicleRoutingTransportCosts.class));
UpdateLoads updateLoads = new UpdateLoads(stateManager);
VehicleRoute route = VehicleRoute.emptyRoute();
updateLoads.informInsertionStarts(Arrays.asList(route), Collections.<Job>emptyList());
Capacity loadAtBeginning = stateManager.getRouteState(route, StateFactory.LOAD_AT_BEGINNING, Capacity.class);
assertEquals(0.,loadAtBeginning.get(0),0.1);
assertEquals(0.,stateManager.getRouteState(route, StateFactory.LOAD_AT_END, Capacity.class).get(0),0.1);
}
@Test
public void whenVehcicleRouteIsNotEmpty_loadsAtBeginningAndEndShouldBeCalculatedCorrectly(){
StateManager stateManager = new StateManager(mock(VehicleRoutingTransportCosts.class));
UpdateLoads updateLoads = new UpdateLoads(stateManager);
Service service = mock(Service.class);
Capacity capacity = Capacity.Builder.newInstance().addDimension(0, 1).build();
when(service.getSize()).thenReturn(capacity);
VehicleRoute route = VehicleRoute.Builder.newInstance(vehicle, mock(Driver.class))
.addService(service).build();
updateLoads.informInsertionStarts(Arrays.asList(route), Collections.<Job>emptyList());
assertEquals(0.,stateManager.getRouteState(route, StateFactory.LOAD_AT_BEGINNING, Capacity.class).get(0),0.1);
assertEquals(1.,stateManager.getRouteState(route, StateFactory.LOAD_AT_END, Capacity.class).get(0),0.1);
}
@Test
public void whenVehcicleRouteIsNotEmpty_multipleLoadsAtBeginningAndEndShouldBeCalculatedCorrectly(){
StateManager stateManager = new StateManager(mock(VehicleRoutingTransportCosts.class));
UpdateLoads updateLoads = new UpdateLoads(stateManager);
Service service = mock(Service.class);
Capacity capacity = Capacity.Builder.newInstance().addDimension(0, 1).addDimension(1,2).build();
when(service.getSize()).thenReturn(capacity);
VehicleRoute route = VehicleRoute.Builder.newInstance(vehicle, mock(Driver.class))
.addService(service).build();
updateLoads.informInsertionStarts(Arrays.asList(route), Collections.<Job>emptyList());
assertEquals(0.,stateManager.getRouteState(route, StateFactory.LOAD_AT_BEGINNING, Capacity.class).get(0),0.1);
assertEquals(0.,stateManager.getRouteState(route, StateFactory.LOAD_AT_BEGINNING, Capacity.class).get(1),0.1);
assertEquals(1.,stateManager.getRouteState(route, StateFactory.LOAD_AT_END, Capacity.class).get(0),0.1);
assertEquals(2.,stateManager.getRouteState(route, StateFactory.LOAD_AT_END, Capacity.class).get(1),0.1);
}
@Test
public void whenVehcicleRouteHasTwoActivities_loadsAtBeginningAndEndShouldBeCalculatedCorrectly(){
StateManager stateManager = new StateManager(mock(VehicleRoutingTransportCosts.class));
UpdateLoads updateLoads = new UpdateLoads(stateManager);
Service service = mock(Service.class);
when(service.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0, 1).build());
Service service2 = mock(Service.class);
when(service2.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0, 10).build());
VehicleRoute route = VehicleRoute.Builder.newInstance(vehicle, mock(Driver.class))
.addService(service).addService(service2).build();
updateLoads.informInsertionStarts(Arrays.asList(route), Collections.<Job>emptyList());
assertEquals(0.,stateManager.getRouteState(route, StateFactory.LOAD_AT_BEGINNING, Capacity.class).get(0),0.1);
assertEquals(11.,stateManager.getRouteState(route, StateFactory.LOAD_AT_END, Capacity.class).get(0),0.1);
}
@Test
public void whenVehcicleRouteHasTwoActivitiesWithMultipleCapDims_loadsAtBeginningAndEndShouldBeCalculatedCorrectly(){
StateManager stateManager = new StateManager(mock(VehicleRoutingTransportCosts.class));
UpdateLoads updateLoads = new UpdateLoads(stateManager);
Service service = mock(Service.class);
when(service.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0, 1).addDimension(1, 3).build());
Service service2 = mock(Service.class);
when(service2.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0, 10).addDimension(1, 14).build());
VehicleRoute route = VehicleRoute.Builder.newInstance(vehicle, mock(Driver.class))
.addService(service).addService(service2).build();
updateLoads.informInsertionStarts(Arrays.asList(route), Collections.<Job>emptyList());
assertEquals(0.,stateManager.getRouteState(route, StateFactory.LOAD_AT_BEGINNING, Capacity.class).get(0),0.1);
assertEquals(0.,stateManager.getRouteState(route, StateFactory.LOAD_AT_BEGINNING, Capacity.class).get(1),0.1);
assertEquals(11.,stateManager.getRouteState(route, StateFactory.LOAD_AT_END, Capacity.class).get(0),0.1);
assertEquals(17.,stateManager.getRouteState(route, StateFactory.LOAD_AT_END, Capacity.class).get(1),0.1);
}
@Test
public void whenVehicleRouteHasTwoActivities_loadsAtActivitiesShouldBeCalculatedCorrectly(){
StateManager stateManager = new StateManager(mock(VehicleRoutingTransportCosts.class));
UpdateLoads updateLoads = new UpdateLoads(stateManager);
RouteActivityVisitor routeActivityVisitor = new RouteActivityVisitor();
routeActivityVisitor.addActivityVisitor(updateLoads);
Service service = mock(Service.class);
when(service.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0, 1).build());
Service service2 = mock(Service.class);
when(service2.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0, 10).build());
VehicleRoute route = VehicleRoute.Builder.newInstance(vehicle, mock(Driver.class))
.addService(service).addService(service2).build();
routeActivityVisitor.visit(route);
assertEquals(1.,stateManager.getActivityState(route.getActivities().get(0), StateFactory.LOAD, Capacity.class).get(0),0.1);
assertEquals(11.,stateManager.getActivityState(route.getActivities().get(1), StateFactory.LOAD, Capacity.class).get(0),0.1);
}
@Test
public void whenVehicleRouteHasTwoActivitiesWithMultipleCapDims_loadsAtActivitiesShouldBeCalculatedCorrectly(){
StateManager stateManager = new StateManager(mock(VehicleRoutingTransportCosts.class));
UpdateLoads updateLoads = new UpdateLoads(stateManager);
RouteActivityVisitor routeActivityVisitor = new RouteActivityVisitor();
routeActivityVisitor.addActivityVisitor(updateLoads);
Service service = mock(Service.class);
when(service.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0, 1).addDimension(1, 3).build());
Service service2 = mock(Service.class);
when(service2.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0, 10).addDimension(1, 13).build());
VehicleRoute route = VehicleRoute.Builder.newInstance(vehicle, mock(Driver.class))
.addService(service).addService(service2).build();
routeActivityVisitor.visit(route);
assertEquals(1.,stateManager.getActivityState(route.getActivities().get(0), StateFactory.LOAD, Capacity.class).get(0),0.1);
assertEquals(3.,stateManager.getActivityState(route.getActivities().get(0), StateFactory.LOAD, Capacity.class).get(1),0.1);
assertEquals(11.,stateManager.getActivityState(route.getActivities().get(1), StateFactory.LOAD, Capacity.class).get(0),0.1);
assertEquals(16.,stateManager.getActivityState(route.getActivities().get(1), StateFactory.LOAD, Capacity.class).get(1),0.1);
}
@Test
public void whenVehcicleRouteHasPickupAndDelivery_loadsAtBeginningAndEndShouldBeCalculatedCorrectly(){
StateManager stateManager = new StateManager(mock(VehicleRoutingTransportCosts.class));
UpdateLoads updateLoads = new UpdateLoads(stateManager);
Pickup pickup = mock(Pickup.class);
when(pickup.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0, 1).build());
Delivery delivery = mock(Delivery.class);
when(delivery.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0, 10).build());
VehicleRoute route = VehicleRoute.Builder.newInstance(vehicle, mock(Driver.class))
.addService(pickup).addService(delivery).build();
updateLoads.informInsertionStarts(Arrays.asList(route), Collections.<Job>emptyList());
assertEquals(10.,stateManager.getRouteState(route, StateFactory.LOAD_AT_BEGINNING, Capacity.class).get(0),0.1);
assertEquals(1.,stateManager.getRouteState(route, StateFactory.LOAD_AT_END, Capacity.class).get(0),0.1);
}
@Test
public void whenVehcicleRouteHasPickupAndDeliveryWithMultipleCapDims_loadsAtBeginningAndEndShouldBeCalculatedCorrectly(){
StateManager stateManager = new StateManager(mock(VehicleRoutingTransportCosts.class));
UpdateLoads updateLoads = new UpdateLoads(stateManager);
Pickup pickup = mock(Pickup.class);
when(pickup.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0, 1).addDimension(1, 4).build());
Delivery delivery = mock(Delivery.class);
when(delivery.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0, 10).addDimension(1, 13).build());
VehicleRoute route = VehicleRoute.Builder.newInstance(vehicle, mock(Driver.class))
.addService(pickup).addService(delivery).build();
updateLoads.informInsertionStarts(Arrays.asList(route), Collections.<Job>emptyList());
assertEquals(10.,stateManager.getRouteState(route, StateFactory.LOAD_AT_BEGINNING, Capacity.class).get(0),0.1);
assertEquals(13.,stateManager.getRouteState(route, StateFactory.LOAD_AT_BEGINNING, Capacity.class).get(1),0.1);
assertEquals(1.,stateManager.getRouteState(route, StateFactory.LOAD_AT_END, Capacity.class).get(0),0.1);
assertEquals(4.,stateManager.getRouteState(route, StateFactory.LOAD_AT_END, Capacity.class).get(1),0.1);
}
@Test
public void whenVehcicleRouteHasPickupAndDelivery_loadsAtActivitiesShouldBeCalculatedCorrectly(){
StateManager stateManager = new StateManager(mock(VehicleRoutingTransportCosts.class));
UpdateLoads updateLoads = new UpdateLoads(stateManager);
RouteActivityVisitor routeActivityVisitor = new RouteActivityVisitor();
routeActivityVisitor.addActivityVisitor(updateLoads);
Pickup pickup = mock(Pickup.class);
when(pickup.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0, 1).build());
Delivery delivery = mock(Delivery.class);
Capacity capacity2 = Capacity.Builder.newInstance().addDimension(0, 10).build();
when(delivery.getSize()).thenReturn(capacity2);
VehicleRoute route = VehicleRoute.Builder.newInstance(vehicle, mock(Driver.class))
.addService(pickup).addService(delivery).build();
updateLoads.informInsertionStarts(Arrays.asList(route), Collections.<Job>emptyList());
routeActivityVisitor.visit(route);
assertEquals(11.,stateManager.getActivityState(route.getActivities().get(0), StateFactory.LOAD, Capacity.class).get(0),0.1);
assertEquals(1.,stateManager.getActivityState(route.getActivities().get(1), StateFactory.LOAD, Capacity.class).get(0),0.1);
}
@Test
public void whenVehcicleRouteHasPickupAndDeliveryWithMultipleCapDims_loadsAtActivitiesShouldBeCalculatedCorrectly(){
StateManager stateManager = new StateManager(mock(VehicleRoutingTransportCosts.class));
UpdateLoads updateLoads = new UpdateLoads(stateManager);
RouteActivityVisitor routeActivityVisitor = new RouteActivityVisitor();
routeActivityVisitor.addActivityVisitor(updateLoads);
Pickup pickup = mock(Pickup.class);
when(pickup.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0, 1).addDimension(1, 4).build());
Delivery delivery = mock(Delivery.class);
Capacity capacity2 = Capacity.Builder.newInstance().addDimension(0, 10).addDimension(1, 14).build();
when(delivery.getSize()).thenReturn(capacity2);
VehicleRoute route = VehicleRoute.Builder.newInstance(vehicle, mock(Driver.class))
.addService(pickup).addService(delivery).build();
updateLoads.informInsertionStarts(Arrays.asList(route), Collections.<Job>emptyList());
routeActivityVisitor.visit(route);
assertEquals(11.,stateManager.getActivityState(route.getActivities().get(0), StateFactory.LOAD, Capacity.class).get(0),0.1);
assertEquals(18.,stateManager.getActivityState(route.getActivities().get(0), StateFactory.LOAD, Capacity.class).get(1),0.1);
assertEquals(1.,stateManager.getActivityState(route.getActivities().get(1), StateFactory.LOAD, Capacity.class).get(0),0.1);
assertEquals(4.,stateManager.getActivityState(route.getActivities().get(1), StateFactory.LOAD, Capacity.class).get(1),0.1);
}
@Test
public void whenPickupIsInsertedIntoVehcicleRouteWithPickupAndDelivery_loadsAtBeginningAndEndShouldBeCalculatedCorrectly(){
StateManager stateManager = new StateManager(mock(VehicleRoutingTransportCosts.class));
UpdateLoads updateLoads = new UpdateLoads(stateManager);
RouteActivityVisitor routeActivityVisitor = new RouteActivityVisitor();
routeActivityVisitor.addActivityVisitor(updateLoads);
Pickup pickup = mock(Pickup.class);
when(pickup.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0, 1).build());
Delivery delivery = mock(Delivery.class);
Capacity capacity2 = Capacity.Builder.newInstance().addDimension(0, 10).build();
when(delivery.getSize()).thenReturn(capacity2);
Pickup pickup2insert = mock(Pickup.class);
when(pickup2insert.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0, 2).build());
VehicleRoute route = VehicleRoute.Builder.newInstance(vehicle, mock(Driver.class))
.addService(pickup).addService(delivery).build();
updateLoads.informInsertionStarts(Arrays.asList(route), Collections.<Job>emptyList());
updateLoads.informJobInserted(pickup2insert, route, 0., 0.);
assertEquals(10.,stateManager.getRouteState(route, StateFactory.LOAD_AT_BEGINNING, Capacity.class).get(0),0.1);
assertEquals(3.,stateManager.getRouteState(route, StateFactory.LOAD_AT_END, Capacity.class).get(0),0.1);
}
@Test
public void whenPickupIsInsertedIntoVehcicleRouteWithPickupAndDeliveryWithMultipleCapDims_loadsAtBeginningAndEndShouldBeCalculatedCorrectly(){
StateManager stateManager = new StateManager(mock(VehicleRoutingTransportCosts.class));
UpdateLoads updateLoads = new UpdateLoads(stateManager);
RouteActivityVisitor routeActivityVisitor = new RouteActivityVisitor();
routeActivityVisitor.addActivityVisitor(updateLoads);
Pickup pickup = mock(Pickup.class);
when(pickup.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0, 1).addDimension(1, 3).build());
Delivery delivery = mock(Delivery.class);
Capacity capacity2 = Capacity.Builder.newInstance().addDimension(0, 10).addDimension(1, 15).build();
when(delivery.getSize()).thenReturn(capacity2);
Pickup pickup2insert = mock(Pickup.class);
when(pickup2insert.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0, 2).addDimension(1, 4).build());
VehicleRoute route = VehicleRoute.Builder.newInstance(vehicle, mock(Driver.class))
.addService(pickup).addService(delivery).build();
updateLoads.informInsertionStarts(Arrays.asList(route), Collections.<Job>emptyList());
updateLoads.informJobInserted(pickup2insert, route, 0., 0.);
assertEquals(10.,stateManager.getRouteState(route, StateFactory.LOAD_AT_BEGINNING, Capacity.class).get(0),0.1);
assertEquals(15.,stateManager.getRouteState(route, StateFactory.LOAD_AT_BEGINNING, Capacity.class).get(1),0.1);
assertEquals(3.,stateManager.getRouteState(route, StateFactory.LOAD_AT_END, Capacity.class).get(0),0.1);
assertEquals(7.,stateManager.getRouteState(route, StateFactory.LOAD_AT_END, Capacity.class).get(1),0.1);
}
@Test
public void whenDeliveryIsInsertedIntoVehcicleRouteWithPickupAndDelivery_loadsAtBeginningAndEndShouldBeCalculatedCorrectly(){
StateManager stateManager = new StateManager(mock(VehicleRoutingTransportCosts.class));
UpdateLoads updateLoads = new UpdateLoads(stateManager);
RouteActivityVisitor routeActivityVisitor = new RouteActivityVisitor();
routeActivityVisitor.addActivityVisitor(updateLoads);
Pickup pickup = mock(Pickup.class);
when(pickup.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0, 1).build());
Delivery delivery = mock(Delivery.class);
Capacity size = Capacity.Builder.newInstance().addDimension(0, 10).build();
when(delivery.getSize()).thenReturn(size);
Delivery delivery2insert = mock(Delivery.class);
Capacity size2 = Capacity.Builder.newInstance().addDimension(0, 20).build();
when(delivery2insert.getSize()).thenReturn(size2);
VehicleRoute route = VehicleRoute.Builder.newInstance(vehicle, mock(Driver.class))
.addService(pickup).addService(delivery).build();
updateLoads.informInsertionStarts(Arrays.asList(route), Collections.<Job>emptyList());
updateLoads.informJobInserted(delivery2insert, route, 0., 0.);
assertEquals(30.,stateManager.getRouteState(route, StateFactory.LOAD_AT_BEGINNING,Capacity.class).get(0),0.1);
assertEquals(1.,stateManager.getRouteState(route, StateFactory.LOAD_AT_END,Capacity.class).get(0),0.1);
}
@Test
public void whenDeliveryIsInsertedIntoVehcicleRouteWithPickupAndDeliveryWithMultipleCapDims_loadsAtBeginningAndEndShouldBeCalculatedCorrectly(){
StateManager stateManager = new StateManager(mock(VehicleRoutingTransportCosts.class));
UpdateLoads updateLoads = new UpdateLoads(stateManager);
RouteActivityVisitor routeActivityVisitor = new RouteActivityVisitor();
routeActivityVisitor.addActivityVisitor(updateLoads);
Pickup pickup = mock(Pickup.class);
when(pickup.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0, 1).addDimension(1, 3).build());
Delivery delivery = mock(Delivery.class);
Capacity size = Capacity.Builder.newInstance().addDimension(0, 10).addDimension(1, 14).build();
when(delivery.getSize()).thenReturn(size);
Delivery delivery2insert = mock(Delivery.class);
Capacity size2 = Capacity.Builder.newInstance().addDimension(0, 20).addDimension(1, 25).build();
when(delivery2insert.getSize()).thenReturn(size2);
VehicleRoute route = VehicleRoute.Builder.newInstance(vehicle, mock(Driver.class))
.addService(pickup).addService(delivery).build();
updateLoads.informInsertionStarts(Arrays.asList(route), Collections.<Job>emptyList());
updateLoads.informJobInserted(delivery2insert, route, 0., 0.);
assertEquals(30.,stateManager.getRouteState(route, StateFactory.LOAD_AT_BEGINNING,Capacity.class).get(0),0.1);
assertEquals(39.,stateManager.getRouteState(route, StateFactory.LOAD_AT_BEGINNING,Capacity.class).get(1),0.1);
assertEquals(1.,stateManager.getRouteState(route, StateFactory.LOAD_AT_END,Capacity.class).get(0),0.1);
assertEquals(3.,stateManager.getRouteState(route, StateFactory.LOAD_AT_END,Capacity.class).get(1),0.1);
}
}

202
jsprit-core/src/test/java/jsprit/core/algorithm/state/UpdateMaxCapacityUtilizationAtActivitiesByLookingBackwardInRouteTest.java
View file

@ -1,202 +0,0 @@
/*******************************************************************************
* Copyright (c) 2014 Stefan Schroeder.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 3.0 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
*
* Contributors:
* Stefan Schroeder - initial API and implementation
******************************************************************************/
package jsprit.core.algorithm.state;
import static org.junit.Assert.assertEquals;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import java.util.Arrays;
import java.util.Collections;
import jsprit.core.problem.Capacity;
import jsprit.core.problem.cost.VehicleRoutingTransportCosts;
import jsprit.core.problem.driver.Driver;
import jsprit.core.problem.job.Delivery;
import jsprit.core.problem.job.Job;
import jsprit.core.problem.job.Pickup;
import jsprit.core.problem.solution.route.ReverseRouteActivityVisitor;
import jsprit.core.problem.solution.route.RouteActivityVisitor;
import jsprit.core.problem.solution.route.VehicleRoute;
import jsprit.core.problem.solution.route.state.StateFactory;
import jsprit.core.problem.vehicle.Vehicle;
import jsprit.core.problem.vehicle.VehicleType;
import org.junit.Before;
import org.junit.Test;
public class UpdateMaxCapacityUtilizationAtActivitiesByLookingBackwardInRouteTest {
private Vehicle vehicle;
@Before
public void doBefore(){
vehicle = mock(Vehicle.class);
VehicleType type = mock(VehicleType.class);
when(type.getCapacityDimensions()).thenReturn(Capacity.Builder.newInstance().addDimension(0, 10000)
.addDimension(1, 10000)
.addDimension(2, 10000)
.addDimension(3, 10000)
.addDimension(4, 10000)
.addDimension(5, 10000).build());
when(vehicle.getType()).thenReturn(type);
}
@Test
public void whenVehicleRouteHasPickupAndDelivery_maxLoadAtEachActivityShouldBeCalculatedCorrectly(){
StateManager stateManager = new StateManager(mock(VehicleRoutingTransportCosts.class));
UpdateLoads updateLoad = new UpdateLoads(stateManager);
UpdateMaxCapacityUtilisationAtActivitiesByLookingBackwardInRoute updateMaxLoad = new UpdateMaxCapacityUtilisationAtActivitiesByLookingBackwardInRoute(stateManager);
RouteActivityVisitor routeActivityVisitor = new RouteActivityVisitor();
routeActivityVisitor.addActivityVisitor(updateLoad);
routeActivityVisitor.addActivityVisitor(updateMaxLoad);
Pickup pickup = mock(Pickup.class);
when(pickup.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0, 1).build());
Delivery delivery = mock(Delivery.class);
when(delivery.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0, 10).build());
VehicleRoute route = VehicleRoute.Builder.newInstance(vehicle, mock(Driver.class))
.addService(pickup).addService(delivery).build();
updateLoad.informInsertionStarts(Arrays.asList(route), Collections.<Job>emptyList());
routeActivityVisitor.visit(route);
assertEquals(11,stateManager.getActivityState(route.getActivities().get(0), StateFactory.PAST_MAXLOAD, Capacity.class).get(0));
assertEquals(11,stateManager.getActivityState(route.getActivities().get(1), StateFactory.PAST_MAXLOAD, Capacity.class).get(0));
}
@Test
public void whenVehicleRouteHasPickupAndDeliveryWithMultipleCapDims_futureMaxLoadAtEachActivityShouldBeCalculatedCorrectly(){
StateManager stateManager = new StateManager(mock(VehicleRoutingTransportCosts.class));
UpdateLoads updateLoad = new UpdateLoads(stateManager);
UpdateMaxCapacityUtilisationAtActivitiesByLookingBackwardInRoute updateMaxLoad = new UpdateMaxCapacityUtilisationAtActivitiesByLookingBackwardInRoute(stateManager);
RouteActivityVisitor routeActivityVisitor = new RouteActivityVisitor();
routeActivityVisitor.addActivityVisitor(updateLoad);
routeActivityVisitor.addActivityVisitor(updateMaxLoad);
Pickup pickup = mock(Pickup.class);
when(pickup.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0, 1)
.addDimension(1, 5).build());
Delivery delivery = mock(Delivery.class);
when(delivery.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0, 10)
.addDimension(1, 3).build());
VehicleRoute route = VehicleRoute.Builder.newInstance(vehicle, mock(Driver.class))
.addService(pickup).addService(delivery).build();
updateLoad.informInsertionStarts(Arrays.asList(route), Collections.<Job>emptyList());
routeActivityVisitor.visit(route);
assertEquals(11,stateManager.getActivityState(route.getActivities().get(0), StateFactory.PAST_MAXLOAD, Capacity.class).get(0),0.1);
assertEquals(8,stateManager.getActivityState(route.getActivities().get(0), StateFactory.PAST_MAXLOAD, Capacity.class).get(1),0.1);
assertEquals(11,stateManager.getActivityState(route.getActivities().get(1), StateFactory.PAST_MAXLOAD, Capacity.class).get(0),0.1);
assertEquals(8,stateManager.getActivityState(route.getActivities().get(1), StateFactory.PAST_MAXLOAD, Capacity.class).get(1),0.1);
}
@Test
public void whenVehicleRouteHasPickupAndDeliveryAndPickupWithMultipleCapDims_futureMaxLoadAtEachActivityShouldBeCalculatedCorrectly(){
StateManager stateManager = new StateManager(mock(VehicleRoutingTransportCosts.class));
UpdateLoads updateLoad = new UpdateLoads(stateManager);
UpdateMaxCapacityUtilisationAtActivitiesByLookingBackwardInRoute updateMaxLoad = new UpdateMaxCapacityUtilisationAtActivitiesByLookingBackwardInRoute(stateManager);
RouteActivityVisitor routeActivityVisitor = new RouteActivityVisitor();
routeActivityVisitor.addActivityVisitor(updateLoad);
routeActivityVisitor.addActivityVisitor(updateMaxLoad);
Pickup pickup = mock(Pickup.class);
when(pickup.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0, 1)
.addDimension(1, 5).build());
Delivery delivery = mock(Delivery.class);
when(delivery.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0, 10)
.addDimension(1, 3).build());
Pickup pickup2 = mock(Pickup.class);
when(pickup2.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0, 3)
.addDimension(1, 8).build());
VehicleRoute route = VehicleRoute.Builder.newInstance(vehicle, mock(Driver.class))
.addService(pickup).addService(delivery).addService(pickup2).build();
updateLoad.informInsertionStarts(Arrays.asList(route), Collections.<Job>emptyList());
routeActivityVisitor.visit(route);
assertEquals(11,stateManager.getActivityState(route.getActivities().get(0), StateFactory.PAST_MAXLOAD, Capacity.class).get(0));
assertEquals(8,stateManager.getActivityState(route.getActivities().get(0), StateFactory.PAST_MAXLOAD, Capacity.class).get(1));
assertEquals(11,stateManager.getActivityState(route.getActivities().get(1), StateFactory.PAST_MAXLOAD, Capacity.class).get(0));
assertEquals(8,stateManager.getActivityState(route.getActivities().get(1), StateFactory.PAST_MAXLOAD, Capacity.class).get(1));
assertEquals(11,stateManager.getActivityState(route.getActivities().get(2), StateFactory.PAST_MAXLOAD, Capacity.class).get(0));
assertEquals(13,stateManager.getActivityState(route.getActivities().get(2), StateFactory.PAST_MAXLOAD, Capacity.class).get(1));
}
@Test
public void whenVehicleRouteHasPickupAndDeliveryAndPickupWithMultipleCapDims_futureMaxLoadAtEachActivityShouldBeCalculatedCorrectly_v2(){
StateManager stateManager = new StateManager(mock(VehicleRoutingTransportCosts.class));
UpdateLoads updateLoad = new UpdateLoads(stateManager);
UpdateMaxCapacityUtilisationAtActivitiesByLookingForwardInRoute updateMaxLoad = new UpdateMaxCapacityUtilisationAtActivitiesByLookingForwardInRoute(stateManager);
RouteActivityVisitor routeActivityVisitor = new RouteActivityVisitor();
routeActivityVisitor.addActivityVisitor(updateLoad);
ReverseRouteActivityVisitor revRouteActivityVisitor = new ReverseRouteActivityVisitor();
revRouteActivityVisitor.addActivityVisitor(updateMaxLoad);
Pickup pickup = mock(Pickup.class);
when(pickup.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0, 1)
.addDimension(1, 5).build());
Delivery delivery = mock(Delivery.class);
when(delivery.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0, 10)
.addDimension(1, 3).build());
Pickup pickup2 = mock(Pickup.class);
when(pickup2.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0, 3)
.addDimension(1, 8).addDimension(4, 29).build());
VehicleRoute route = VehicleRoute.Builder.newInstance(vehicle, mock(Driver.class))
.addService(pickup).addService(delivery).addService(pickup2).build();
updateLoad.informInsertionStarts(Arrays.asList(route), Collections.<Job>emptyList());
routeActivityVisitor.visit(route);
revRouteActivityVisitor.visit(route);
assertEquals(11,stateManager.getActivityState(route.getActivities().get(0), StateFactory.FUTURE_MAXLOAD, Capacity.class).get(0));
assertEquals(13,stateManager.getActivityState(route.getActivities().get(0), StateFactory.FUTURE_MAXLOAD, Capacity.class).get(1));
assertEquals(29,stateManager.getActivityState(route.getActivities().get(0), StateFactory.FUTURE_MAXLOAD, Capacity.class).get(4));
assertEquals(4,stateManager.getActivityState(route.getActivities().get(1), StateFactory.FUTURE_MAXLOAD, Capacity.class).get(0));
assertEquals(13,stateManager.getActivityState(route.getActivities().get(1), StateFactory.FUTURE_MAXLOAD, Capacity.class).get(1));
assertEquals(29,stateManager.getActivityState(route.getActivities().get(1), StateFactory.FUTURE_MAXLOAD, Capacity.class).get(4));
assertEquals(4,stateManager.getActivityState(route.getActivities().get(2), StateFactory.FUTURE_MAXLOAD, Capacity.class).get(0));
assertEquals(13,stateManager.getActivityState(route.getActivities().get(2), StateFactory.FUTURE_MAXLOAD, Capacity.class).get(1));
}
}

209
jsprit-core/src/test/java/jsprit/core/algorithm/state/UpdateMaxCapacityUtilizationAtActivitiesByLookingForwardInRouteTest.java
View file

@ -1,209 +0,0 @@
/*******************************************************************************
* Copyright (c) 2014 Stefan Schroeder.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 3.0 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
*
* Contributors:
* Stefan Schroeder - initial API and implementation
******************************************************************************/
package jsprit.core.algorithm.state;
import static org.junit.Assert.assertEquals;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import java.util.Arrays;
import java.util.Collections;
import jsprit.core.problem.Capacity;
import jsprit.core.problem.cost.VehicleRoutingTransportCosts;
import jsprit.core.problem.driver.Driver;
import jsprit.core.problem.job.Delivery;
import jsprit.core.problem.job.Job;
import jsprit.core.problem.job.Pickup;
import jsprit.core.problem.solution.route.ReverseRouteActivityVisitor;
import jsprit.core.problem.solution.route.RouteActivityVisitor;
import jsprit.core.problem.solution.route.VehicleRoute;
import jsprit.core.problem.solution.route.state.StateFactory;
import jsprit.core.problem.vehicle.Vehicle;
import jsprit.core.problem.vehicle.VehicleType;
import org.junit.Before;
import org.junit.Test;
public class UpdateMaxCapacityUtilizationAtActivitiesByLookingForwardInRouteTest {
private Vehicle vehicle;
@Before
public void doBefore(){
vehicle = mock(Vehicle.class);
VehicleType type = mock(VehicleType.class);
when(type.getCapacityDimensions()).thenReturn(Capacity.Builder.newInstance().addDimension(0, 10000)
.addDimension(1, 10000)
.addDimension(2, 10000)
.addDimension(3, 10000)
.addDimension(4, 10000)
.addDimension(5, 10000).build());
when(vehicle.getType()).thenReturn(type);
}
@Test
public void whenVehicleRouteHasPickupAndDelivery_futureMaxLoadAtEachActivityShouldBeCalculatedCorrectly(){
StateManager stateManager = new StateManager(mock(VehicleRoutingTransportCosts.class));
UpdateLoads updateLoad = new UpdateLoads(stateManager);
UpdateMaxCapacityUtilisationAtActivitiesByLookingForwardInRoute updateMaxLoad = new UpdateMaxCapacityUtilisationAtActivitiesByLookingForwardInRoute(stateManager);
RouteActivityVisitor routeActivityVisitor = new RouteActivityVisitor();
routeActivityVisitor.addActivityVisitor(updateLoad);
ReverseRouteActivityVisitor revRouteActivityVisitor = new ReverseRouteActivityVisitor();
revRouteActivityVisitor.addActivityVisitor(updateMaxLoad);
Pickup pickup = mock(Pickup.class);
when(pickup.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0, 1).build());
Delivery delivery = mock(Delivery.class);
when(delivery.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0, 10).build());
VehicleRoute route = VehicleRoute.Builder.newInstance(vehicle, mock(Driver.class))
.addService(pickup).addService(delivery).build();
updateLoad.informInsertionStarts(Arrays.asList(route), Collections.<Job>emptyList());
routeActivityVisitor.visit(route);
revRouteActivityVisitor.visit(route);
assertEquals(11,stateManager.getActivityState(route.getActivities().get(0), StateFactory.FUTURE_MAXLOAD, Capacity.class).get(0),0.1);
assertEquals(1,stateManager.getActivityState(route.getActivities().get(1), StateFactory.FUTURE_MAXLOAD, Capacity.class).get(0),0.1);
}
@Test
public void whenVehicleRouteHasPickupAndDeliveryWithMultipleCapDims_futureMaxLoadAtEachActivityShouldBeCalculatedCorrectly(){
StateManager stateManager = new StateManager(mock(VehicleRoutingTransportCosts.class));
UpdateLoads updateLoad = new UpdateLoads(stateManager);
UpdateMaxCapacityUtilisationAtActivitiesByLookingForwardInRoute updateMaxLoad = new UpdateMaxCapacityUtilisationAtActivitiesByLookingForwardInRoute(stateManager);
RouteActivityVisitor routeActivityVisitor = new RouteActivityVisitor();
routeActivityVisitor.addActivityVisitor(updateLoad);
ReverseRouteActivityVisitor revRouteActivityVisitor = new ReverseRouteActivityVisitor();
revRouteActivityVisitor.addActivityVisitor(updateMaxLoad);
Pickup pickup = mock(Pickup.class);
when(pickup.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0, 1)
.addDimension(1, 5).build());
Delivery delivery = mock(Delivery.class);
when(delivery.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0, 10)
.addDimension(1, 3).build());
VehicleRoute route = VehicleRoute.Builder.newInstance(vehicle, mock(Driver.class))
.addService(pickup).addService(delivery).build();
updateLoad.informInsertionStarts(Arrays.asList(route), Collections.<Job>emptyList());
routeActivityVisitor.visit(route);
revRouteActivityVisitor.visit(route);
assertEquals(11,stateManager.getActivityState(route.getActivities().get(0), StateFactory.FUTURE_MAXLOAD, Capacity.class).get(0),0.1);
assertEquals(8,stateManager.getActivityState(route.getActivities().get(0), StateFactory.FUTURE_MAXLOAD, Capacity.class).get(1),0.1);
assertEquals(1,stateManager.getActivityState(route.getActivities().get(1), StateFactory.FUTURE_MAXLOAD, Capacity.class).get(0),0.1);
assertEquals(5,stateManager.getActivityState(route.getActivities().get(1), StateFactory.FUTURE_MAXLOAD, Capacity.class).get(1),0.1);
}
@Test
public void whenVehicleRouteHasPickupAndDeliveryAndPickupWithMultipleCapDims_futureMaxLoadAtEachActivityShouldBeCalculatedCorrectly(){
StateManager stateManager = new StateManager(mock(VehicleRoutingTransportCosts.class));
UpdateLoads updateLoad = new UpdateLoads(stateManager);
UpdateMaxCapacityUtilisationAtActivitiesByLookingForwardInRoute updateMaxLoad = new UpdateMaxCapacityUtilisationAtActivitiesByLookingForwardInRoute(stateManager);
RouteActivityVisitor routeActivityVisitor = new RouteActivityVisitor();
routeActivityVisitor.addActivityVisitor(updateLoad);
ReverseRouteActivityVisitor revRouteActivityVisitor = new ReverseRouteActivityVisitor();
revRouteActivityVisitor.addActivityVisitor(updateMaxLoad);
Pickup pickup = mock(Pickup.class);
when(pickup.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0, 1)
.addDimension(1, 5).build());
Delivery delivery = mock(Delivery.class);
when(delivery.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0, 10)
.addDimension(1, 3).build());
Pickup pickup2 = mock(Pickup.class);
when(pickup2.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0, 3)
.addDimension(1, 8).build());
VehicleRoute route = VehicleRoute.Builder.newInstance(vehicle, mock(Driver.class))
.addService(pickup).addService(delivery).addService(pickup2).build();
updateLoad.informInsertionStarts(Arrays.asList(route), Collections.<Job>emptyList());
routeActivityVisitor.visit(route);
revRouteActivityVisitor.visit(route);
assertEquals(11,stateManager.getActivityState(route.getActivities().get(0), StateFactory.FUTURE_MAXLOAD, Capacity.class).get(0));
assertEquals(13,stateManager.getActivityState(route.getActivities().get(0), StateFactory.FUTURE_MAXLOAD, Capacity.class).get(1));
assertEquals(4,stateManager.getActivityState(route.getActivities().get(1), StateFactory.FUTURE_MAXLOAD, Capacity.class).get(0));
assertEquals(13,stateManager.getActivityState(route.getActivities().get(1), StateFactory.FUTURE_MAXLOAD, Capacity.class).get(1));
assertEquals(4,stateManager.getActivityState(route.getActivities().get(2), StateFactory.FUTURE_MAXLOAD, Capacity.class).get(0));
assertEquals(13,stateManager.getActivityState(route.getActivities().get(2), StateFactory.FUTURE_MAXLOAD, Capacity.class).get(1));
}
@Test
public void whenVehicleRouteHasPickupAndDeliveryAndPickupWithMultipleCapDims_futureMaxLoadAtEachActivityShouldBeCalculatedCorrectly_v2(){
StateManager stateManager = new StateManager(mock(VehicleRoutingTransportCosts.class));
UpdateLoads updateLoad = new UpdateLoads(stateManager);
UpdateMaxCapacityUtilisationAtActivitiesByLookingForwardInRoute updateMaxLoad = new UpdateMaxCapacityUtilisationAtActivitiesByLookingForwardInRoute(stateManager);
RouteActivityVisitor routeActivityVisitor = new RouteActivityVisitor();
routeActivityVisitor.addActivityVisitor(updateLoad);
ReverseRouteActivityVisitor revRouteActivityVisitor = new ReverseRouteActivityVisitor();
revRouteActivityVisitor.addActivityVisitor(updateMaxLoad);
Pickup pickup = mock(Pickup.class);
when(pickup.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0, 1)
.addDimension(1, 5).build());
Delivery delivery = mock(Delivery.class);
when(delivery.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0, 10)
.addDimension(1, 3).build());
Pickup pickup2 = mock(Pickup.class);
when(pickup2.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0, 3)
.addDimension(1, 8).addDimension(4, 29).build());
VehicleRoute route = VehicleRoute.Builder.newInstance(vehicle, mock(Driver.class))
.addService(pickup).addService(delivery).addService(pickup2).build();
updateLoad.informInsertionStarts(Arrays.asList(route), Collections.<Job>emptyList());
routeActivityVisitor.visit(route);
revRouteActivityVisitor.visit(route);
assertEquals(11,stateManager.getActivityState(route.getActivities().get(0), StateFactory.FUTURE_MAXLOAD, Capacity.class).get(0));
assertEquals(13,stateManager.getActivityState(route.getActivities().get(0), StateFactory.FUTURE_MAXLOAD, Capacity.class).get(1));
assertEquals(29,stateManager.getActivityState(route.getActivities().get(0), StateFactory.FUTURE_MAXLOAD, Capacity.class).get(4));
assertEquals(4,stateManager.getActivityState(route.getActivities().get(1), StateFactory.FUTURE_MAXLOAD, Capacity.class).get(0));
assertEquals(13,stateManager.getActivityState(route.getActivities().get(1), StateFactory.FUTURE_MAXLOAD, Capacity.class).get(1));
assertEquals(29,stateManager.getActivityState(route.getActivities().get(1), StateFactory.FUTURE_MAXLOAD, Capacity.class).get(4));
assertEquals(4,stateManager.getActivityState(route.getActivities().get(2), StateFactory.FUTURE_MAXLOAD, Capacity.class).get(0));
assertEquals(13,stateManager.getActivityState(route.getActivities().get(2), StateFactory.FUTURE_MAXLOAD, Capacity.class).get(1));
}
}

184
jsprit-core/src/test/java/jsprit/core/algorithm/state/UpdateMaxCapacityUtilizationAtRouteTest.java
View file

@ -1,184 +0,0 @@
/*******************************************************************************
* Copyright (c) 2014 Stefan Schroeder.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 3.0 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
*
* Contributors:
* Stefan Schroeder - initial API and implementation
******************************************************************************/
package jsprit.core.algorithm.state;
import static org.junit.Assert.assertEquals;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import java.util.Arrays;
import java.util.Collections;
import jsprit.core.problem.Capacity;
import jsprit.core.problem.cost.VehicleRoutingTransportCosts;
import jsprit.core.problem.driver.Driver;
import jsprit.core.problem.job.Delivery;
import jsprit.core.problem.job.Job;
import jsprit.core.problem.job.Pickup;
import jsprit.core.problem.solution.route.RouteActivityVisitor;
import jsprit.core.problem.solution.route.VehicleRoute;
import jsprit.core.problem.solution.route.state.StateFactory;
import jsprit.core.problem.vehicle.Vehicle;
import jsprit.core.problem.vehicle.VehicleType;
import org.junit.Before;
import org.junit.Test;
public class UpdateMaxCapacityUtilizationAtRouteTest {
private Vehicle vehicle;
@Before
public void doBefore(){
vehicle = mock(Vehicle.class);
VehicleType type = mock(VehicleType.class);
when(type.getCapacityDimensions()).thenReturn(Capacity.Builder.newInstance().addDimension(0, 10000)
.addDimension(1, 10000)
.addDimension(2, 10000)
.addDimension(3, 10000)
.addDimension(4, 10000)
.addDimension(5, 10000).build());
when(vehicle.getType()).thenReturn(type);
}
@Test
public void whenVehicleRouteHasPickupAndDelivery_maxLoadAtEachActivityShouldBeCalculatedCorrectly(){
StateManager stateManager = new StateManager(mock(VehicleRoutingTransportCosts.class));
UpdateLoads updateLoad = new UpdateLoads(stateManager);
UpdateMaxCapacityUtilisationAtRoute updateMaxLoad = new UpdateMaxCapacityUtilisationAtRoute(stateManager);
RouteActivityVisitor routeActivityVisitor = new RouteActivityVisitor();
routeActivityVisitor.addActivityVisitor(updateLoad);
routeActivityVisitor.addActivityVisitor(updateMaxLoad);
Pickup pickup = mock(Pickup.class);
when(pickup.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0, 1).build());
Delivery delivery = mock(Delivery.class);
when(delivery.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0, 10).build());
VehicleRoute route = VehicleRoute.Builder.newInstance(vehicle, mock(Driver.class))
.addService(pickup).addService(delivery).build();
updateLoad.informInsertionStarts(Arrays.asList(route), Collections.<Job>emptyList());
routeActivityVisitor.visit(route);
assertEquals(11,stateManager.getRouteState(route, StateFactory.MAXLOAD, Capacity.class).get(0));
}
@Test
public void whenVehicleRouteHasPickupAndDeliveryWithMultipleCapDims_futureMaxLoadAtEachActivityShouldBeCalculatedCorrectly(){
StateManager stateManager = new StateManager(mock(VehicleRoutingTransportCosts.class));
UpdateLoads updateLoad = new UpdateLoads(stateManager);
UpdateMaxCapacityUtilisationAtRoute updateMaxLoad = new UpdateMaxCapacityUtilisationAtRoute(stateManager);
RouteActivityVisitor routeActivityVisitor = new RouteActivityVisitor();
routeActivityVisitor.addActivityVisitor(updateLoad);
routeActivityVisitor.addActivityVisitor(updateMaxLoad);
Pickup pickup = mock(Pickup.class);
when(pickup.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0, 1)
.addDimension(1, 5).build());
Delivery delivery = mock(Delivery.class);
when(delivery.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0, 10)
.addDimension(1, 3).build());
VehicleRoute route = VehicleRoute.Builder.newInstance(vehicle, mock(Driver.class))
.addService(pickup).addService(delivery).build();
updateLoad.informInsertionStarts(Arrays.asList(route), Collections.<Job>emptyList());
routeActivityVisitor.visit(route);
assertEquals(11,stateManager.getRouteState(route, StateFactory.MAXLOAD, Capacity.class).get(0),0.1);
assertEquals(8,stateManager.getRouteState(route, StateFactory.MAXLOAD, Capacity.class).get(1),0.1);
assertEquals(11,stateManager.getRouteState(route, StateFactory.MAXLOAD, Capacity.class).get(0),0.1);
assertEquals(8,stateManager.getRouteState(route, StateFactory.MAXLOAD, Capacity.class).get(1),0.1);
}
@Test
public void whenVehicleRouteHasPickupAndDeliveryAndPickupWithMultipleCapDims_futureMaxLoadAtEachActivityShouldBeCalculatedCorrectly(){
StateManager stateManager = new StateManager(mock(VehicleRoutingTransportCosts.class));
UpdateLoads updateLoad = new UpdateLoads(stateManager);
UpdateMaxCapacityUtilisationAtRoute updateMaxLoad = new UpdateMaxCapacityUtilisationAtRoute(stateManager);
RouteActivityVisitor routeActivityVisitor = new RouteActivityVisitor();
routeActivityVisitor.addActivityVisitor(updateLoad);
routeActivityVisitor.addActivityVisitor(updateMaxLoad);
Pickup pickup = mock(Pickup.class);
when(pickup.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0, 1)
.addDimension(1, 5).build());
Delivery delivery = mock(Delivery.class);
when(delivery.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0, 10)
.addDimension(1, 3).build());
Pickup pickup2 = mock(Pickup.class);
when(pickup2.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0, 3)
.addDimension(1, 8).build());
VehicleRoute route = VehicleRoute.Builder.newInstance(vehicle, mock(Driver.class))
.addService(pickup).addService(delivery).addService(pickup2).build();
updateLoad.informInsertionStarts(Arrays.asList(route), Collections.<Job>emptyList());
routeActivityVisitor.visit(route);
assertEquals(11,stateManager.getRouteState(route, StateFactory.MAXLOAD, Capacity.class).get(0));
assertEquals(13,stateManager.getRouteState(route, StateFactory.MAXLOAD, Capacity.class).get(1));
}
@Test
public void whenVehicleRouteHasPickupAndDeliveryAndPickupWithMultipleCapDims_futureMaxLoadAtEachActivityShouldBeCalculatedCorrectly_v2(){
StateManager stateManager = new StateManager(mock(VehicleRoutingTransportCosts.class));
UpdateLoads updateLoad = new UpdateLoads(stateManager);
UpdateMaxCapacityUtilisationAtRoute updateMaxLoad = new UpdateMaxCapacityUtilisationAtRoute(stateManager);
RouteActivityVisitor routeActivityVisitor = new RouteActivityVisitor();
routeActivityVisitor.addActivityVisitor(updateLoad);
routeActivityVisitor.addActivityVisitor(updateMaxLoad);
Pickup pickup = mock(Pickup.class);
when(pickup.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0, 1)
.addDimension(1, 5).build());
Delivery delivery = mock(Delivery.class);
when(delivery.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0, 10)
.addDimension(1, 3).build());
Pickup pickup2 = mock(Pickup.class);
when(pickup2.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0, 3)
.addDimension(1, 8).addDimension(4, 29).build());
VehicleRoute route = VehicleRoute.Builder.newInstance(vehicle, mock(Driver.class))
.addService(pickup).addService(delivery).addService(pickup2).build();
updateLoad.informInsertionStarts(Arrays.asList(route), Collections.<Job>emptyList());
routeActivityVisitor.visit(route);
assertEquals(11,stateManager.getRouteState(route, StateFactory.MAXLOAD, Capacity.class).get(0));
assertEquals(13,stateManager.getRouteState(route, StateFactory.MAXLOAD, Capacity.class).get(1));
assertEquals(29,stateManager.getRouteState(route, StateFactory.MAXLOAD, Capacity.class).get(4));
}
}

51
jsprit-core/src/test/java/jsprit/core/algorithm/state/UpdatePracticalTimeWindowTest.java
View file

@ -18,24 +18,30 @@
******************************************************************************/ ******************************************************************************/
package jsprit.core.algorithm.state; package jsprit.core.algorithm.state;
import static org.junit.Assert.assertEquals; import jsprit.core.problem.AbstractActivity;
import static org.mockito.Mockito.mock; import jsprit.core.problem.JobActivityFactory;
import static org.mockito.Mockito.when; import jsprit.core.problem.VehicleRoutingProblem;
import jsprit.core.problem.Capacity;
import jsprit.core.problem.cost.VehicleRoutingTransportCosts; import jsprit.core.problem.cost.VehicleRoutingTransportCosts;
import jsprit.core.problem.driver.Driver; import jsprit.core.problem.driver.Driver;
import jsprit.core.problem.job.Delivery; import jsprit.core.problem.job.Delivery;
import jsprit.core.problem.job.Job;
import jsprit.core.problem.job.Pickup; import jsprit.core.problem.job.Pickup;
import jsprit.core.problem.solution.route.ReverseRouteActivityVisitor; import jsprit.core.problem.solution.route.ReverseRouteActivityVisitor;
import jsprit.core.problem.solution.route.VehicleRoute; import jsprit.core.problem.solution.route.VehicleRoute;
import jsprit.core.problem.solution.route.activity.TimeWindow; import jsprit.core.problem.solution.route.activity.TimeWindow;
import jsprit.core.problem.solution.route.state.StateFactory; import jsprit.core.problem.solution.route.state.StateFactory;
import jsprit.core.problem.vehicle.Vehicle; import jsprit.core.problem.vehicle.Vehicle;
import jsprit.core.problem.vehicle.VehicleImpl;
import jsprit.core.problem.vehicle.VehicleType;
import jsprit.core.util.CostFactory; import jsprit.core.util.CostFactory;
import org.junit.Before; import org.junit.Before;
import org.junit.Test; import org.junit.Test;
import java.util.List;
import static org.junit.Assert.assertEquals;
import static org.mockito.Mockito.mock;
public class UpdatePracticalTimeWindowTest { public class UpdatePracticalTimeWindowTest {
private VehicleRoutingTransportCosts routingCosts; private VehicleRoutingTransportCosts routingCosts;
@ -56,25 +62,22 @@ public class UpdatePracticalTimeWindowTest {
reverseActivityVisitor = new ReverseRouteActivityVisitor(); reverseActivityVisitor = new ReverseRouteActivityVisitor();
reverseActivityVisitor.addActivityVisitor(new UpdatePracticalTimeWindows(stateManager, routingCosts)); reverseActivityVisitor.addActivityVisitor(new UpdatePracticalTimeWindows(stateManager, routingCosts));
Pickup pickup = mock(Pickup.class); Pickup pickup = (Pickup) Pickup.Builder.newInstance("pick").setLocationId("0,20").setTimeWindow(TimeWindow.newInstance(0, 30)).build();
when(pickup.getTimeWindow()).thenReturn(TimeWindow.newInstance(0, 30)); Delivery delivery = (Delivery) Delivery.Builder.newInstance("del").setLocationId("20,20").setTimeWindow(TimeWindow.newInstance(10, 40)).build();
when(pickup.getLocationId()).thenReturn("0,20"); Pickup pickup2 = (Pickup) Pickup.Builder.newInstance("pick2").setLocationId("20,0").setTimeWindow(TimeWindow.newInstance(20, 50)).build();
Delivery delivery = mock(Delivery.class); Vehicle vehicle = VehicleImpl.Builder.newInstance("v").setStartLocationId("0,0").setType(mock(VehicleType.class)).build();
when(delivery.getTimeWindow()).thenReturn(TimeWindow.newInstance(10, 40));
when(delivery.getLocationId()).thenReturn("20,20"); VehicleRoutingProblem.Builder vrpBuilder = VehicleRoutingProblem.Builder.newInstance();
when(delivery.getSize()).thenReturn(Capacity.Builder.newInstance().build()); final VehicleRoutingProblem vrp = vrpBuilder.addJob(pickup).addJob(pickup2).addJob(delivery).build();
Pickup pickup2 = mock(Pickup.class); route = VehicleRoute.Builder.newInstance(vehicle, mock(Driver.class)).setJobActivityFactory(new JobActivityFactory() {
when(pickup2.getTimeWindow()).thenReturn(TimeWindow.newInstance(20, 50)); @Override
when(pickup2.getLocationId()).thenReturn("20,0"); public List<AbstractActivity> createActivity(Job job) {
return vrp.copyAndGetActivities(job);
Vehicle vehicle = mock(Vehicle.class); }
when(vehicle.getStartLocationId()).thenReturn("0,0"); })
when(vehicle.getLatestArrival()).thenReturn(Double.MAX_VALUE); .addService(pickup).addService(delivery).addService(pickup2).build();
route = VehicleRoute.Builder.newInstance(vehicle, mock(Driver.class))
.addService(pickup).addService(delivery).addService(pickup2).build();
reverseActivityVisitor.visit(route); reverseActivityVisitor.visit(route);

120
jsprit-core/src/test/java/jsprit/core/problem/constraint/LoadConstraintTest.java
View file

@ -1,7 +1,10 @@
package jsprit.core.problem.constraint; package jsprit.core.problem.constraint;
import jsprit.core.algorithm.state.StateManager; import jsprit.core.algorithm.state.StateManager;
import jsprit.core.problem.AbstractActivity;
import jsprit.core.problem.Capacity; import jsprit.core.problem.Capacity;
import jsprit.core.problem.JobActivityFactory;
import jsprit.core.problem.VehicleRoutingProblem;
import jsprit.core.problem.cost.VehicleRoutingTransportCosts; import jsprit.core.problem.cost.VehicleRoutingTransportCosts;
import jsprit.core.problem.job.*; import jsprit.core.problem.job.*;
import jsprit.core.problem.misc.JobInsertionContext; import jsprit.core.problem.misc.JobInsertionContext;
@ -14,15 +17,14 @@ import org.junit.Test;
import java.util.Arrays; import java.util.Arrays;
import java.util.Collections; import java.util.Collections;
import java.util.List;
import static org.junit.Assert.assertEquals; import static org.junit.Assert.*;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.mockito.Mockito.mock; import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when; import static org.mockito.Mockito.when;
/** /**
* Created by schroeder on 13.07.14. * unit tests to test load constraints
*/ */
public class LoadConstraintTest { public class LoadConstraintTest {
@ -41,29 +43,55 @@ public class LoadConstraintTest {
when(type.getCapacityDimensions()).thenReturn(Capacity.Builder.newInstance().addDimension(0,20).build()); when(type.getCapacityDimensions()).thenReturn(Capacity.Builder.newInstance().addDimension(0,20).build());
when(vehicle.getType()).thenReturn(type); when(vehicle.getType()).thenReturn(type);
Service s1 = mock(Service.class); VehicleRoutingProblem.Builder serviceProblemBuilder = VehicleRoutingProblem.Builder.newInstance();
when(s1.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0,10).build()); Service s1 = Service.Builder.newInstance("s").addSizeDimension(0,10).setLocationId("loc").build();
Service s2 = mock(Service.class); Service s2 = Service.Builder.newInstance("s2").addSizeDimension(0,5).setLocationId("loc").build();
when(s2.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0,5).build()); serviceProblemBuilder.addJob(s1).addJob(s2);
final VehicleRoutingProblem serviceProblem = serviceProblemBuilder.build();
Pickup pickup = mock(Pickup.class); final VehicleRoutingProblem.Builder pdProblemBuilder = VehicleRoutingProblem.Builder.newInstance();
when(pickup.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0, 10).build()); Pickup pickup = (Pickup) Pickup.Builder.newInstance("pick").addSizeDimension(0,10).setLocationId("loc").build();
Delivery delivery = mock(Delivery.class); Delivery delivery = (Delivery) Delivery.Builder.newInstance("del").addSizeDimension(0,5).setLocationId("loc").build();
when(delivery.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0,5).build()); pdProblemBuilder.addJob(pickup).addJob(delivery);
final VehicleRoutingProblem pdProblem = pdProblemBuilder.build();
Shipment shipment1 = mock(Shipment.class); final VehicleRoutingProblem.Builder shipmentProblemBuilder = VehicleRoutingProblem.Builder.newInstance();
when(shipment1.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0, 10).build()); Shipment shipment1 = Shipment.Builder.newInstance("s1").addSizeDimension(0,10).setPickupLocation("pick").setDeliveryLocation("del").build();
Shipment shipment2 = mock(Shipment.class); Shipment shipment2 = Shipment.Builder.newInstance("s2").addSizeDimension(0,5).setPickupLocation("pick").setDeliveryLocation("del").build();
when(shipment2.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0, 5).build()); shipmentProblemBuilder.addJob(shipment1).addJob(shipment2).build();
final VehicleRoutingProblem shipmentProblem = shipmentProblemBuilder.build();
serviceRoute = VehicleRoute.Builder.newInstance(vehicle).addService(s1).addService(s2).build(); VehicleRoute.Builder serviceRouteBuilder = VehicleRoute.Builder.newInstance(vehicle);
pickup_delivery_route = VehicleRoute.Builder.newInstance(vehicle).addService(pickup).addService(delivery).build(); serviceRouteBuilder.setJobActivityFactory(new JobActivityFactory() {
shipment_route = VehicleRoute.Builder.newInstance(vehicle).addPickup(shipment1).addPickup(shipment2).addDelivery(shipment2).addDelivery(shipment1).build();
@Override
public List<AbstractActivity> createActivity(Job job) {
return serviceProblem.copyAndGetActivities(job);
}
});
serviceRoute = serviceRouteBuilder.addService(s1).addService(s2).build();
VehicleRoute.Builder pdRouteBuilder = VehicleRoute.Builder.newInstance(vehicle);
pdRouteBuilder.setJobActivityFactory(new JobActivityFactory() {
@Override
public List<AbstractActivity> createActivity(Job job) {
return pdProblem.copyAndGetActivities(job);
}
});
pickup_delivery_route = pdRouteBuilder.addService(pickup).addService(delivery).build();
VehicleRoute.Builder shipmentRouteBuilder = VehicleRoute.Builder.newInstance(vehicle);
shipmentRouteBuilder.setJobActivityFactory(new JobActivityFactory() {
@Override
public List<AbstractActivity> createActivity(Job job) {
return shipmentProblem.copyAndGetActivities(job);
}
});
shipment_route = shipmentRouteBuilder.addPickup(shipment1).addPickup(shipment2).addDelivery(shipment2).addDelivery(shipment1).build();
stateManager = new StateManager(mock(VehicleRoutingTransportCosts.class)); stateManager = new StateManager(mock(VehicleRoutingTransportCosts.class));
stateManager.updateLoadStates(); stateManager.updateLoadStates();
stateManager.informInsertionStarts(Arrays.asList(serviceRoute, pickup_delivery_route, shipment_route), Collections.<Job>emptyList());
} }
@ -72,6 +100,7 @@ public class LoadConstraintTest {
*/ */
@Test @Test
public void whenServiceRouteAndNewServiceFitsIn_itShouldReturnFulfilled(){ public void whenServiceRouteAndNewServiceFitsIn_itShouldReturnFulfilled(){
stateManager.informInsertionStarts(Arrays.asList(serviceRoute), Collections.<Job>emptyList());
Service s = mock(Service.class); Service s = mock(Service.class);
when(s.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0,5).build()); when(s.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0,5).build());
ServiceLoadRouteLevelConstraint loadconstraint = new ServiceLoadRouteLevelConstraint(stateManager); ServiceLoadRouteLevelConstraint loadconstraint = new ServiceLoadRouteLevelConstraint(stateManager);
@ -82,6 +111,7 @@ public class LoadConstraintTest {
@Test @Test
public void whenServiceRouteAndNewServiceFitsInBetweenStartAndAct1_itShouldReturnFulfilled(){ public void whenServiceRouteAndNewServiceFitsInBetweenStartAndAct1_itShouldReturnFulfilled(){
stateManager.informInsertionStarts(Arrays.asList(serviceRoute), Collections.<Job>emptyList());
Service s = mock(Service.class); Service s = mock(Service.class);
Capacity newSize = Capacity.Builder.newInstance().addDimension(0, 5).build(); Capacity newSize = Capacity.Builder.newInstance().addDimension(0, 5).build();
when(s.getSize()).thenReturn(newSize); when(s.getSize()).thenReturn(newSize);
@ -98,6 +128,7 @@ public class LoadConstraintTest {
@Test @Test
public void whenServiceRouteAndNewServiceFitsInBetweenAc1AndAct2_itShouldReturnFulfilled(){ public void whenServiceRouteAndNewServiceFitsInBetweenAc1AndAct2_itShouldReturnFulfilled(){
stateManager.informInsertionStarts(Arrays.asList(serviceRoute), Collections.<Job>emptyList());
Service s = mock(Service.class); Service s = mock(Service.class);
Capacity newSize = Capacity.Builder.newInstance().addDimension(0, 5).build(); Capacity newSize = Capacity.Builder.newInstance().addDimension(0, 5).build();
when(s.getSize()).thenReturn(newSize); when(s.getSize()).thenReturn(newSize);
@ -114,6 +145,7 @@ public class LoadConstraintTest {
@Test @Test
public void whenServiceRouteAndNewServiceFitsInBetweenAc2AndEnd_itShouldReturnFulfilled(){ public void whenServiceRouteAndNewServiceFitsInBetweenAc2AndEnd_itShouldReturnFulfilled(){
stateManager.informInsertionStarts(Arrays.asList(serviceRoute), Collections.<Job>emptyList());
Service s = mock(Service.class); Service s = mock(Service.class);
Capacity newSize = Capacity.Builder.newInstance().addDimension(0, 5).build(); Capacity newSize = Capacity.Builder.newInstance().addDimension(0, 5).build();
when(s.getSize()).thenReturn(newSize); when(s.getSize()).thenReturn(newSize);
@ -133,6 +165,7 @@ public class LoadConstraintTest {
*/ */
@Test @Test
public void whenServiceRouteAndNewServiceDoesNotFitInBetweenStartAndAct1_itShouldReturnFulfilled(){ public void whenServiceRouteAndNewServiceDoesNotFitInBetweenStartAndAct1_itShouldReturnFulfilled(){
stateManager.informInsertionStarts(Arrays.asList(serviceRoute), Collections.<Job>emptyList());
Service s = mock(Service.class); Service s = mock(Service.class);
Capacity newSize = Capacity.Builder.newInstance().addDimension(0, 6).build(); Capacity newSize = Capacity.Builder.newInstance().addDimension(0, 6).build();
when(s.getSize()).thenReturn(newSize); when(s.getSize()).thenReturn(newSize);
@ -149,6 +182,7 @@ public class LoadConstraintTest {
@Test @Test
public void whenServiceRouteAndNewServiceDoesNotFitInBetweenAc1AndAct2_itShouldReturnFulfilled(){ public void whenServiceRouteAndNewServiceDoesNotFitInBetweenAc1AndAct2_itShouldReturnFulfilled(){
stateManager.informInsertionStarts(Arrays.asList(serviceRoute), Collections.<Job>emptyList());
Service s = mock(Service.class); Service s = mock(Service.class);
Capacity newSize = Capacity.Builder.newInstance().addDimension(0, 6).build(); Capacity newSize = Capacity.Builder.newInstance().addDimension(0, 6).build();
when(s.getSize()).thenReturn(newSize); when(s.getSize()).thenReturn(newSize);
@ -165,6 +199,7 @@ public class LoadConstraintTest {
@Test @Test
public void whenServiceRouteAndNewServiceDoesNotFitInBetweenAc2AndEnd_itShouldReturnFulfilled(){ public void whenServiceRouteAndNewServiceDoesNotFitInBetweenAc2AndEnd_itShouldReturnFulfilled(){
stateManager.informInsertionStarts(Arrays.asList(serviceRoute), Collections.<Job>emptyList());
Service s = mock(Service.class); Service s = mock(Service.class);
Capacity newSize = Capacity.Builder.newInstance().addDimension(0, 6).build(); Capacity newSize = Capacity.Builder.newInstance().addDimension(0, 6).build();
when(s.getSize()).thenReturn(newSize); when(s.getSize()).thenReturn(newSize);
@ -182,6 +217,7 @@ public class LoadConstraintTest {
@Test @Test
public void whenServiceRouteAndNewServiceDoesNotFitIn_itShouldReturnFulfilled(){ public void whenServiceRouteAndNewServiceDoesNotFitIn_itShouldReturnFulfilled(){
stateManager.informInsertionStarts(Arrays.asList(serviceRoute), Collections.<Job>emptyList());
Service s = mock(Service.class); Service s = mock(Service.class);
when(s.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0,6).build()); when(s.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0,6).build());
ServiceLoadRouteLevelConstraint loadconstraint = new ServiceLoadRouteLevelConstraint(stateManager); ServiceLoadRouteLevelConstraint loadconstraint = new ServiceLoadRouteLevelConstraint(stateManager);
@ -197,6 +233,7 @@ public class LoadConstraintTest {
*/ */
@Test @Test
public void whenPDRouteRouteAndNewPickupFitsIn_itShouldReturnFulfilled(){ public void whenPDRouteRouteAndNewPickupFitsIn_itShouldReturnFulfilled(){
stateManager.informInsertionStarts(Arrays.asList(pickup_delivery_route), Collections.<Job>emptyList());
Pickup s = mock(Pickup.class); Pickup s = mock(Pickup.class);
when(s.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0,10).build()); when(s.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0,10).build());
ServiceLoadRouteLevelConstraint loadconstraint = new ServiceLoadRouteLevelConstraint(stateManager); ServiceLoadRouteLevelConstraint loadconstraint = new ServiceLoadRouteLevelConstraint(stateManager);
@ -207,6 +244,7 @@ public class LoadConstraintTest {
@Test @Test
public void whenPDRouteRouteAndNewDeliveryFitsIn_itShouldReturnFulfilled(){ public void whenPDRouteRouteAndNewDeliveryFitsIn_itShouldReturnFulfilled(){
stateManager.informInsertionStarts(Arrays.asList(pickup_delivery_route), Collections.<Job>emptyList());
Delivery s = mock(Delivery.class); Delivery s = mock(Delivery.class);
when(s.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0,15).build()); when(s.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0,15).build());
ServiceLoadRouteLevelConstraint loadconstraint = new ServiceLoadRouteLevelConstraint(stateManager); ServiceLoadRouteLevelConstraint loadconstraint = new ServiceLoadRouteLevelConstraint(stateManager);
@ -217,6 +255,7 @@ public class LoadConstraintTest {
@Test @Test
public void whenPDRouteRouteAndNewPickupDoesNotFitIn_itShouldReturnNotFulfilled(){ public void whenPDRouteRouteAndNewPickupDoesNotFitIn_itShouldReturnNotFulfilled(){
stateManager.informInsertionStarts(Arrays.asList(pickup_delivery_route), Collections.<Job>emptyList());
Pickup s = mock(Pickup.class); Pickup s = mock(Pickup.class);
when(s.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0,11).build()); when(s.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0,11).build());
ServiceLoadRouteLevelConstraint loadconstraint = new ServiceLoadRouteLevelConstraint(stateManager); ServiceLoadRouteLevelConstraint loadconstraint = new ServiceLoadRouteLevelConstraint(stateManager);
@ -227,6 +266,7 @@ public class LoadConstraintTest {
@Test @Test
public void whenPDRouteRouteAndNewDeliveryDoesNotFitIn_itShouldReturnNotFulfilled(){ public void whenPDRouteRouteAndNewDeliveryDoesNotFitIn_itShouldReturnNotFulfilled(){
stateManager.informInsertionStarts(Arrays.asList(pickup_delivery_route), Collections.<Job>emptyList());
Delivery s = mock(Delivery.class); Delivery s = mock(Delivery.class);
when(s.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0,16).build()); when(s.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0,16).build());
ServiceLoadRouteLevelConstraint loadconstraint = new ServiceLoadRouteLevelConstraint(stateManager); ServiceLoadRouteLevelConstraint loadconstraint = new ServiceLoadRouteLevelConstraint(stateManager);
@ -240,6 +280,7 @@ public class LoadConstraintTest {
*/ */
@Test @Test
public void whenPDRoute_newPickupShouldFitInBetweenStartAndAct1(){ public void whenPDRoute_newPickupShouldFitInBetweenStartAndAct1(){
stateManager.informInsertionStarts(Arrays.asList(pickup_delivery_route), Collections.<Job>emptyList());
Pickup s = mock(Pickup.class); Pickup s = mock(Pickup.class);
Capacity newSize = Capacity.Builder.newInstance().addDimension(0, 5).build(); Capacity newSize = Capacity.Builder.newInstance().addDimension(0, 5).build();
when(s.getSize()).thenReturn(newSize); when(s.getSize()).thenReturn(newSize);
@ -255,6 +296,7 @@ public class LoadConstraintTest {
@Test @Test
public void whenPDRoute_newPickupShouldFitInBetweenAct1AndAct2(){ public void whenPDRoute_newPickupShouldFitInBetweenAct1AndAct2(){
stateManager.informInsertionStarts(Arrays.asList(pickup_delivery_route), Collections.<Job>emptyList());
Pickup s = mock(Pickup.class); Pickup s = mock(Pickup.class);
Capacity newSize = Capacity.Builder.newInstance().addDimension(0, 5).build(); Capacity newSize = Capacity.Builder.newInstance().addDimension(0, 5).build();
when(s.getSize()).thenReturn(newSize); when(s.getSize()).thenReturn(newSize);
@ -270,6 +312,7 @@ public class LoadConstraintTest {
@Test @Test
public void whenPDRoute_newPickupShouldFitInBetweenAct2AndEnd(){ public void whenPDRoute_newPickupShouldFitInBetweenAct2AndEnd(){
stateManager.informInsertionStarts(Arrays.asList(pickup_delivery_route), Collections.<Job>emptyList());
Pickup s = mock(Pickup.class); Pickup s = mock(Pickup.class);
Capacity newSize = Capacity.Builder.newInstance().addDimension(0, 10).build(); Capacity newSize = Capacity.Builder.newInstance().addDimension(0, 10).build();
when(s.getSize()).thenReturn(newSize); when(s.getSize()).thenReturn(newSize);
@ -288,6 +331,7 @@ public class LoadConstraintTest {
*/ */
@Test @Test
public void whenPDRoute_newPickupShouldNotFitInBetweenStartAndAct1(){ public void whenPDRoute_newPickupShouldNotFitInBetweenStartAndAct1(){
stateManager.informInsertionStarts(Arrays.asList(pickup_delivery_route), Collections.<Job>emptyList());
Pickup s = mock(Pickup.class); Pickup s = mock(Pickup.class);
Capacity newSize = Capacity.Builder.newInstance().addDimension(0, 6).build(); Capacity newSize = Capacity.Builder.newInstance().addDimension(0, 6).build();
when(s.getSize()).thenReturn(newSize); when(s.getSize()).thenReturn(newSize);
@ -303,6 +347,7 @@ public class LoadConstraintTest {
@Test @Test
public void whenPDRoute_newPickupShouldNotFitInBetweenAct1AndAct2(){ public void whenPDRoute_newPickupShouldNotFitInBetweenAct1AndAct2(){
stateManager.informInsertionStarts(Arrays.asList(pickup_delivery_route), Collections.<Job>emptyList());
Pickup s = mock(Pickup.class); Pickup s = mock(Pickup.class);
Capacity newSize = Capacity.Builder.newInstance().addDimension(0, 6).build(); Capacity newSize = Capacity.Builder.newInstance().addDimension(0, 6).build();
when(s.getSize()).thenReturn(newSize); when(s.getSize()).thenReturn(newSize);
@ -318,6 +363,7 @@ public class LoadConstraintTest {
@Test @Test
public void whenPDRoute_newPickupShouldNotFitInBetweenAct2AndEnd(){ public void whenPDRoute_newPickupShouldNotFitInBetweenAct2AndEnd(){
stateManager.informInsertionStarts(Arrays.asList(pickup_delivery_route), Collections.<Job>emptyList());
Pickup s = mock(Pickup.class); Pickup s = mock(Pickup.class);
Capacity newSize = Capacity.Builder.newInstance().addDimension(0, 11).build(); Capacity newSize = Capacity.Builder.newInstance().addDimension(0, 11).build();
when(s.getSize()).thenReturn(newSize); when(s.getSize()).thenReturn(newSize);
@ -337,6 +383,7 @@ public class LoadConstraintTest {
*/ */
@Test @Test
public void whenPDRoute_newDeliveryShouldFitInBetweenStartAndAct1(){ public void whenPDRoute_newDeliveryShouldFitInBetweenStartAndAct1(){
stateManager.informInsertionStarts(Arrays.asList(pickup_delivery_route), Collections.<Job>emptyList());
Delivery s = mock(Delivery.class); Delivery s = mock(Delivery.class);
Capacity newSize = Capacity.Builder.newInstance().addDimension(0, 15).build(); Capacity newSize = Capacity.Builder.newInstance().addDimension(0, 15).build();
when(s.getSize()).thenReturn(newSize); when(s.getSize()).thenReturn(newSize);
@ -352,6 +399,7 @@ public class LoadConstraintTest {
@Test @Test
public void whenPDRoute_newDeliveryShouldNotFitInBetweenStartAndAct1(){ public void whenPDRoute_newDeliveryShouldNotFitInBetweenStartAndAct1(){
stateManager.informInsertionStarts(Arrays.asList(pickup_delivery_route), Collections.<Job>emptyList());
Delivery s = mock(Delivery.class); Delivery s = mock(Delivery.class);
Capacity newSize = Capacity.Builder.newInstance().addDimension(0, 16).build(); Capacity newSize = Capacity.Builder.newInstance().addDimension(0, 16).build();
when(s.getSize()).thenReturn(newSize); when(s.getSize()).thenReturn(newSize);
@ -367,6 +415,7 @@ public class LoadConstraintTest {
@Test @Test
public void whenPDRoute_newDeliveryShouldFitInBetweenAct1AndAct2(){ public void whenPDRoute_newDeliveryShouldFitInBetweenAct1AndAct2(){
stateManager.informInsertionStarts(Arrays.asList(pickup_delivery_route), Collections.<Job>emptyList());
Delivery s = mock(Delivery.class); Delivery s = mock(Delivery.class);
Capacity newSize = Capacity.Builder.newInstance().addDimension(0, 5).build(); Capacity newSize = Capacity.Builder.newInstance().addDimension(0, 5).build();
when(s.getSize()).thenReturn(newSize); when(s.getSize()).thenReturn(newSize);
@ -382,6 +431,7 @@ public class LoadConstraintTest {
@Test @Test
public void whenPDRoute_newDeliveryNotShouldFitInBetweenAct1AndAct2(){ public void whenPDRoute_newDeliveryNotShouldFitInBetweenAct1AndAct2(){
stateManager.informInsertionStarts(Arrays.asList(pickup_delivery_route), Collections.<Job>emptyList());
Delivery s = mock(Delivery.class); Delivery s = mock(Delivery.class);
Capacity newSize = Capacity.Builder.newInstance().addDimension(0, 6).build(); Capacity newSize = Capacity.Builder.newInstance().addDimension(0, 6).build();
when(s.getSize()).thenReturn(newSize); when(s.getSize()).thenReturn(newSize);
@ -397,6 +447,7 @@ public class LoadConstraintTest {
@Test @Test
public void whenPDRoute_newDeliveryShouldFitInBetweenAct2AndEnd(){ public void whenPDRoute_newDeliveryShouldFitInBetweenAct2AndEnd(){
stateManager.informInsertionStarts(Arrays.asList(pickup_delivery_route), Collections.<Job>emptyList());
Delivery s = mock(Delivery.class); Delivery s = mock(Delivery.class);
Capacity newSize = Capacity.Builder.newInstance().addDimension(0, 5).build(); Capacity newSize = Capacity.Builder.newInstance().addDimension(0, 5).build();
when(s.getSize()).thenReturn(newSize); when(s.getSize()).thenReturn(newSize);
@ -412,6 +463,7 @@ public class LoadConstraintTest {
@Test @Test
public void whenPDRoute_newDeliveryShouldNotFitInBetweenAct2AndEnd(){ public void whenPDRoute_newDeliveryShouldNotFitInBetweenAct2AndEnd(){
stateManager.informInsertionStarts(Arrays.asList(pickup_delivery_route), Collections.<Job>emptyList());
Delivery s = mock(Delivery.class); Delivery s = mock(Delivery.class);
Capacity newSize = Capacity.Builder.newInstance().addDimension(0, 6).build(); Capacity newSize = Capacity.Builder.newInstance().addDimension(0, 6).build();
when(s.getSize()).thenReturn(newSize); when(s.getSize()).thenReturn(newSize);
@ -427,6 +479,7 @@ public class LoadConstraintTest {
@Test @Test
public void whenPDRouteAndNewServiceFitsInBetweenAc1AndAct2_itShouldReturnFulfilled(){ public void whenPDRouteAndNewServiceFitsInBetweenAc1AndAct2_itShouldReturnFulfilled(){
stateManager.informInsertionStarts(Arrays.asList(pickup_delivery_route), Collections.<Job>emptyList());
Service s = mock(Service.class); Service s = mock(Service.class);
Capacity newSize = Capacity.Builder.newInstance().addDimension(0, 5).build(); Capacity newSize = Capacity.Builder.newInstance().addDimension(0, 5).build();
when(s.getSize()).thenReturn(newSize); when(s.getSize()).thenReturn(newSize);
@ -443,6 +496,7 @@ public class LoadConstraintTest {
@Test @Test
public void whenPDRouteAndNewServiceFitsInBetweenAc2AndEnd_itShouldReturnFulfilled(){ public void whenPDRouteAndNewServiceFitsInBetweenAc2AndEnd_itShouldReturnFulfilled(){
stateManager.informInsertionStarts(Arrays.asList(pickup_delivery_route), Collections.<Job>emptyList());
Service s = mock(Service.class); Service s = mock(Service.class);
Capacity newSize = Capacity.Builder.newInstance().addDimension(0, 5).build(); Capacity newSize = Capacity.Builder.newInstance().addDimension(0, 5).build();
when(s.getSize()).thenReturn(newSize); when(s.getSize()).thenReturn(newSize);
@ -462,6 +516,7 @@ public class LoadConstraintTest {
*/ */
@Test @Test
public void whenPDRouteAndNewServiceDoesNotFitInBetweenStartAndAct1_itShouldReturnFulfilled(){ public void whenPDRouteAndNewServiceDoesNotFitInBetweenStartAndAct1_itShouldReturnFulfilled(){
stateManager.informInsertionStarts(Arrays.asList(serviceRoute), Collections.<Job>emptyList());
Service s = mock(Service.class); Service s = mock(Service.class);
Capacity newSize = Capacity.Builder.newInstance().addDimension(0, 6).build(); Capacity newSize = Capacity.Builder.newInstance().addDimension(0, 6).build();
when(s.getSize()).thenReturn(newSize); when(s.getSize()).thenReturn(newSize);
@ -478,6 +533,7 @@ public class LoadConstraintTest {
@Test @Test
public void whenPDRouteAndNewServiceDoesNotFitInBetweenAc1AndAct2_itShouldReturnFulfilled(){ public void whenPDRouteAndNewServiceDoesNotFitInBetweenAc1AndAct2_itShouldReturnFulfilled(){
stateManager.informInsertionStarts(Arrays.asList(pickup_delivery_route), Collections.<Job>emptyList());
Service s = mock(Service.class); Service s = mock(Service.class);
Capacity newSize = Capacity.Builder.newInstance().addDimension(0, 6).build(); Capacity newSize = Capacity.Builder.newInstance().addDimension(0, 6).build();
when(s.getSize()).thenReturn(newSize); when(s.getSize()).thenReturn(newSize);
@ -494,6 +550,7 @@ public class LoadConstraintTest {
@Test @Test
public void whenPDRouteAndNewServiceDoesNotFitInBetweenAc2AndEnd_itShouldReturnFulfilled(){ public void whenPDRouteAndNewServiceDoesNotFitInBetweenAc2AndEnd_itShouldReturnFulfilled(){
stateManager.informInsertionStarts(Arrays.asList(serviceRoute), Collections.<Job>emptyList());
Service s = mock(Service.class); Service s = mock(Service.class);
Capacity newSize = Capacity.Builder.newInstance().addDimension(0, 6).build(); Capacity newSize = Capacity.Builder.newInstance().addDimension(0, 6).build();
when(s.getSize()).thenReturn(newSize); when(s.getSize()).thenReturn(newSize);
@ -511,6 +568,7 @@ public class LoadConstraintTest {
@Test @Test
public void whenPDRouteAndNewServiceDoesNotFitIn_itShouldReturnFulfilled(){ public void whenPDRouteAndNewServiceDoesNotFitIn_itShouldReturnFulfilled(){
stateManager.informInsertionStarts(Arrays.asList(serviceRoute), Collections.<Job>emptyList());
Service s = mock(Service.class); Service s = mock(Service.class);
when(s.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0,6).build()); when(s.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0,6).build());
ServiceLoadRouteLevelConstraint loadconstraint = new ServiceLoadRouteLevelConstraint(stateManager); ServiceLoadRouteLevelConstraint loadconstraint = new ServiceLoadRouteLevelConstraint(stateManager);
@ -529,6 +587,7 @@ pickup(s1) pickup(s2) delivery(s2) deliver(s1)
@Test @Test
public void whenShipmentRouteAndPickupOfNewShipmentShouldFitInBetweenStartAndAct1(){ public void whenShipmentRouteAndPickupOfNewShipmentShouldFitInBetweenStartAndAct1(){
stateManager.informInsertionStarts(Arrays.asList(shipment_route), Collections.<Job>emptyList());
Shipment s = mock(Shipment.class); Shipment s = mock(Shipment.class);
Capacity newSize = Capacity.Builder.newInstance().addDimension(0, 20).build(); Capacity newSize = Capacity.Builder.newInstance().addDimension(0, 20).build();
when(s.getSize()).thenReturn(newSize); when(s.getSize()).thenReturn(newSize);
@ -545,6 +604,7 @@ pickup(s1) pickup(s2) delivery(s2) deliver(s1)
@Test @Test
public void whenShipmentRouteAndPickupOfNewShipmentShouldNotFitInBetweenStartAndAct1(){ public void whenShipmentRouteAndPickupOfNewShipmentShouldNotFitInBetweenStartAndAct1(){
stateManager.informInsertionStarts(Arrays.asList(shipment_route), Collections.<Job>emptyList());
Shipment s = mock(Shipment.class); Shipment s = mock(Shipment.class);
Capacity newSize = Capacity.Builder.newInstance().addDimension(0, 21).build(); Capacity newSize = Capacity.Builder.newInstance().addDimension(0, 21).build();
when(s.getSize()).thenReturn(newSize); when(s.getSize()).thenReturn(newSize);
@ -561,6 +621,7 @@ pickup(s1) pickup(s2) delivery(s2) deliver(s1)
@Test @Test
public void whenShipmentRouteAndPickupOfNewShipmentShouldFitInBetweenAct1AndAct2(){ public void whenShipmentRouteAndPickupOfNewShipmentShouldFitInBetweenAct1AndAct2(){
stateManager.informInsertionStarts(Arrays.asList(shipment_route), Collections.<Job>emptyList());
Shipment s = mock(Shipment.class); Shipment s = mock(Shipment.class);
Capacity newSize = Capacity.Builder.newInstance().addDimension(0, 10).build(); Capacity newSize = Capacity.Builder.newInstance().addDimension(0, 10).build();
when(s.getSize()).thenReturn(newSize); when(s.getSize()).thenReturn(newSize);
@ -577,6 +638,7 @@ pickup(s1) pickup(s2) delivery(s2) deliver(s1)
@Test @Test
public void whenShipmentRouteAndPickupOfNewShipmentShouldNotFitInBetweenAct1AndAct2(){ public void whenShipmentRouteAndPickupOfNewShipmentShouldNotFitInBetweenAct1AndAct2(){
stateManager.informInsertionStarts(Arrays.asList(shipment_route), Collections.<Job>emptyList());
Shipment s = mock(Shipment.class); Shipment s = mock(Shipment.class);
Capacity newSize = Capacity.Builder.newInstance().addDimension(0, 11).build(); Capacity newSize = Capacity.Builder.newInstance().addDimension(0, 11).build();
when(s.getSize()).thenReturn(newSize); when(s.getSize()).thenReturn(newSize);
@ -593,6 +655,7 @@ pickup(s1) pickup(s2) delivery(s2) deliver(s1)
@Test @Test
public void whenShipmentRouteAndPickupOfNewShipmentShouldFitInBetweenAct2AndAct3(){ public void whenShipmentRouteAndPickupOfNewShipmentShouldFitInBetweenAct2AndAct3(){
stateManager.informInsertionStarts(Arrays.asList(shipment_route), Collections.<Job>emptyList());
Shipment s = mock(Shipment.class); Shipment s = mock(Shipment.class);
Capacity newSize = Capacity.Builder.newInstance().addDimension(0, 5).build(); Capacity newSize = Capacity.Builder.newInstance().addDimension(0, 5).build();
when(s.getSize()).thenReturn(newSize); when(s.getSize()).thenReturn(newSize);
@ -609,6 +672,7 @@ pickup(s1) pickup(s2) delivery(s2) deliver(s1)
@Test @Test
public void whenShipmentRouteAndPickupOfNewShipmentShouldNotFitInBetweenAct2AndAct3(){ public void whenShipmentRouteAndPickupOfNewShipmentShouldNotFitInBetweenAct2AndAct3(){
stateManager.informInsertionStarts(Arrays.asList(shipment_route), Collections.<Job>emptyList());
Shipment s = mock(Shipment.class); Shipment s = mock(Shipment.class);
Capacity newSize = Capacity.Builder.newInstance().addDimension(0, 6).build(); Capacity newSize = Capacity.Builder.newInstance().addDimension(0, 6).build();
when(s.getSize()).thenReturn(newSize); when(s.getSize()).thenReturn(newSize);
@ -625,6 +689,7 @@ pickup(s1) pickup(s2) delivery(s2) deliver(s1)
@Test @Test
public void whenShipmentRouteAndPickupOfNewShipmentShouldFitInBetweenAct3AndAct4(){ public void whenShipmentRouteAndPickupOfNewShipmentShouldFitInBetweenAct3AndAct4(){
stateManager.informInsertionStarts(Arrays.asList(shipment_route), Collections.<Job>emptyList());
Shipment s = mock(Shipment.class); Shipment s = mock(Shipment.class);
Capacity newSize = Capacity.Builder.newInstance().addDimension(0, 10).build(); Capacity newSize = Capacity.Builder.newInstance().addDimension(0, 10).build();
when(s.getSize()).thenReturn(newSize); when(s.getSize()).thenReturn(newSize);
@ -641,6 +706,7 @@ pickup(s1) pickup(s2) delivery(s2) deliver(s1)
@Test @Test
public void whenShipmentRouteAndPickupOfNewShipmentShouldNotFitInBetweenAct3AndAct4(){ public void whenShipmentRouteAndPickupOfNewShipmentShouldNotFitInBetweenAct3AndAct4(){
stateManager.informInsertionStarts(Arrays.asList(shipment_route), Collections.<Job>emptyList());
Shipment s = mock(Shipment.class); Shipment s = mock(Shipment.class);
Capacity newSize = Capacity.Builder.newInstance().addDimension(0,11).build(); Capacity newSize = Capacity.Builder.newInstance().addDimension(0,11).build();
when(s.getSize()).thenReturn(newSize); when(s.getSize()).thenReturn(newSize);
@ -657,6 +723,7 @@ pickup(s1) pickup(s2) delivery(s2) deliver(s1)
@Test @Test
public void whenShipmentRouteAndPickupOfNewShipmentShouldFitInBetweenAct4AndEnd(){ public void whenShipmentRouteAndPickupOfNewShipmentShouldFitInBetweenAct4AndEnd(){
stateManager.informInsertionStarts(Arrays.asList(shipment_route), Collections.<Job>emptyList());
Shipment s = mock(Shipment.class); Shipment s = mock(Shipment.class);
Capacity newSize = Capacity.Builder.newInstance().addDimension(0, 20).build(); Capacity newSize = Capacity.Builder.newInstance().addDimension(0, 20).build();
when(s.getSize()).thenReturn(newSize); when(s.getSize()).thenReturn(newSize);
@ -673,6 +740,7 @@ pickup(s1) pickup(s2) delivery(s2) deliver(s1)
@Test @Test
public void whenShipmentRouteAndPickupOfNewShipmentShouldNotFitInBetweenAct4AndEnd(){ public void whenShipmentRouteAndPickupOfNewShipmentShouldNotFitInBetweenAct4AndEnd(){
stateManager.informInsertionStarts(Arrays.asList(shipment_route), Collections.<Job>emptyList());
Shipment s = mock(Shipment.class); Shipment s = mock(Shipment.class);
Capacity newSize = Capacity.Builder.newInstance().addDimension(0,21).build(); Capacity newSize = Capacity.Builder.newInstance().addDimension(0,21).build();
when(s.getSize()).thenReturn(newSize); when(s.getSize()).thenReturn(newSize);
@ -693,6 +761,7 @@ pickup(s1) pickup(s2) delivery(s2) deliver(s1)
@Test @Test
public void whenShipmentRouteAndDeliveryOfNewShipmentShouldFitInBetweenStartAndAct1(){ public void whenShipmentRouteAndDeliveryOfNewShipmentShouldFitInBetweenStartAndAct1(){
stateManager.informInsertionStarts(Arrays.asList(shipment_route), Collections.<Job>emptyList());
Shipment s = mock(Shipment.class); Shipment s = mock(Shipment.class);
Capacity newSize = Capacity.Builder.newInstance().addDimension(0, 20).build(); Capacity newSize = Capacity.Builder.newInstance().addDimension(0, 20).build();
when(s.getSize()).thenReturn(newSize); when(s.getSize()).thenReturn(newSize);
@ -709,6 +778,7 @@ pickup(s1) pickup(s2) delivery(s2) deliver(s1)
@Test @Test
public void whenShipmentRouteAndDeliveryOfNewShipmentShouldNotFitInBetweenStartAndAct1(){ public void whenShipmentRouteAndDeliveryOfNewShipmentShouldNotFitInBetweenStartAndAct1(){
stateManager.informInsertionStarts(Arrays.asList(shipment_route), Collections.<Job>emptyList());
Shipment s = mock(Shipment.class); Shipment s = mock(Shipment.class);
Capacity newSize = Capacity.Builder.newInstance().addDimension(0, 21).build(); Capacity newSize = Capacity.Builder.newInstance().addDimension(0, 21).build();
when(s.getSize()).thenReturn(newSize); when(s.getSize()).thenReturn(newSize);
@ -725,6 +795,7 @@ pickup(s1) pickup(s2) delivery(s2) deliver(s1)
@Test @Test
public void whenShipmentRouteAndDeliveryOfNewShipmentShouldFitInBetweenAct1AndAct2(){ public void whenShipmentRouteAndDeliveryOfNewShipmentShouldFitInBetweenAct1AndAct2(){
stateManager.informInsertionStarts(Arrays.asList(shipment_route), Collections.<Job>emptyList());
Shipment s = mock(Shipment.class); Shipment s = mock(Shipment.class);
Capacity newSize = Capacity.Builder.newInstance().addDimension(0, 10).build(); Capacity newSize = Capacity.Builder.newInstance().addDimension(0, 10).build();
when(s.getSize()).thenReturn(newSize); when(s.getSize()).thenReturn(newSize);
@ -741,6 +812,7 @@ pickup(s1) pickup(s2) delivery(s2) deliver(s1)
@Test @Test
public void whenShipmentRouteAndDeliveryOfNewShipmentShouldNotFitInBetweenAct1AndAct2(){ public void whenShipmentRouteAndDeliveryOfNewShipmentShouldNotFitInBetweenAct1AndAct2(){
stateManager.informInsertionStarts(Arrays.asList(shipment_route), Collections.<Job>emptyList());
Shipment s = mock(Shipment.class); Shipment s = mock(Shipment.class);
Capacity newSize = Capacity.Builder.newInstance().addDimension(0, 11).build(); Capacity newSize = Capacity.Builder.newInstance().addDimension(0, 11).build();
when(s.getSize()).thenReturn(newSize); when(s.getSize()).thenReturn(newSize);
@ -757,6 +829,7 @@ pickup(s1) pickup(s2) delivery(s2) deliver(s1)
@Test @Test
public void whenShipmentRouteAndDeliveryOfNewShipmentShouldFitInBetweenAct2AndAct3(){ public void whenShipmentRouteAndDeliveryOfNewShipmentShouldFitInBetweenAct2AndAct3(){
stateManager.informInsertionStarts(Arrays.asList(shipment_route), Collections.<Job>emptyList());
Shipment s = mock(Shipment.class); Shipment s = mock(Shipment.class);
Capacity newSize = Capacity.Builder.newInstance().addDimension(0, 5).build(); Capacity newSize = Capacity.Builder.newInstance().addDimension(0, 5).build();
when(s.getSize()).thenReturn(newSize); when(s.getSize()).thenReturn(newSize);
@ -773,6 +846,7 @@ pickup(s1) pickup(s2) delivery(s2) deliver(s1)
@Test @Test
public void whenShipmentRouteAndDeliveryOfNewShipmentShouldNotFitInBetweenAct2AndAct3(){ public void whenShipmentRouteAndDeliveryOfNewShipmentShouldNotFitInBetweenAct2AndAct3(){
stateManager.informInsertionStarts(Arrays.asList(shipment_route), Collections.<Job>emptyList());
Shipment s = mock(Shipment.class); Shipment s = mock(Shipment.class);
Capacity newSize = Capacity.Builder.newInstance().addDimension(0, 6).build(); Capacity newSize = Capacity.Builder.newInstance().addDimension(0, 6).build();
when(s.getSize()).thenReturn(newSize); when(s.getSize()).thenReturn(newSize);
@ -789,6 +863,7 @@ pickup(s1) pickup(s2) delivery(s2) deliver(s1)
@Test @Test
public void whenShipmentRouteAndDeliveryOfNewShipmentShouldFitInBetweenAct3AndAct4(){ public void whenShipmentRouteAndDeliveryOfNewShipmentShouldFitInBetweenAct3AndAct4(){
stateManager.informInsertionStarts(Arrays.asList(shipment_route), Collections.<Job>emptyList());
Shipment s = mock(Shipment.class); Shipment s = mock(Shipment.class);
Capacity newSize = Capacity.Builder.newInstance().addDimension(0, 10).build(); Capacity newSize = Capacity.Builder.newInstance().addDimension(0, 10).build();
when(s.getSize()).thenReturn(newSize); when(s.getSize()).thenReturn(newSize);
@ -805,6 +880,7 @@ pickup(s1) pickup(s2) delivery(s2) deliver(s1)
@Test @Test
public void whenShipmentRouteAndDeliveryOfNewShipmentShouldNotFitInBetweenAct3AndAct4(){ public void whenShipmentRouteAndDeliveryOfNewShipmentShouldNotFitInBetweenAct3AndAct4(){
stateManager.informInsertionStarts(Arrays.asList(shipment_route), Collections.<Job>emptyList());
Shipment s = mock(Shipment.class); Shipment s = mock(Shipment.class);
Capacity newSize = Capacity.Builder.newInstance().addDimension(0,11).build(); Capacity newSize = Capacity.Builder.newInstance().addDimension(0,11).build();
when(s.getSize()).thenReturn(newSize); when(s.getSize()).thenReturn(newSize);
@ -821,6 +897,7 @@ pickup(s1) pickup(s2) delivery(s2) deliver(s1)
@Test @Test
public void whenShipmentRouteAndDeliveryOfNewShipmentShouldFitInBetweenAct4AndEnd(){ public void whenShipmentRouteAndDeliveryOfNewShipmentShouldFitInBetweenAct4AndEnd(){
stateManager.informInsertionStarts(Arrays.asList(shipment_route), Collections.<Job>emptyList());
Shipment s = mock(Shipment.class); Shipment s = mock(Shipment.class);
Capacity newSize = Capacity.Builder.newInstance().addDimension(0, 20).build(); Capacity newSize = Capacity.Builder.newInstance().addDimension(0, 20).build();
when(s.getSize()).thenReturn(newSize); when(s.getSize()).thenReturn(newSize);
@ -837,6 +914,7 @@ pickup(s1) pickup(s2) delivery(s2) deliver(s1)
@Test @Test
public void whenShipmentRouteAndDeliveryOfNewShipmentShouldNotFitInBetweenAct4AndEnd(){ public void whenShipmentRouteAndDeliveryOfNewShipmentShouldNotFitInBetweenAct4AndEnd(){
stateManager.informInsertionStarts(Arrays.asList(shipment_route), Collections.<Job>emptyList());
Shipment s = mock(Shipment.class); Shipment s = mock(Shipment.class);
Capacity newSize = Capacity.Builder.newInstance().addDimension(0,21).build(); Capacity newSize = Capacity.Builder.newInstance().addDimension(0,21).build();
when(s.getSize()).thenReturn(newSize); when(s.getSize()).thenReturn(newSize);

13
jsprit-core/src/test/java/jsprit/core/problem/solution/route/VehicleRouteBuilderTest.java
View file

@ -18,16 +18,16 @@
******************************************************************************/ ******************************************************************************/
package jsprit.core.problem.solution.route; package jsprit.core.problem.solution.route;
import static org.junit.Assert.assertEquals;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import jsprit.core.problem.Capacity; import jsprit.core.problem.Capacity;
import jsprit.core.problem.driver.Driver; import jsprit.core.problem.driver.Driver;
import jsprit.core.problem.job.Shipment; import jsprit.core.problem.job.Shipment;
import jsprit.core.problem.vehicle.Vehicle; import jsprit.core.problem.vehicle.Vehicle;
import org.junit.Test; import org.junit.Test;
import static org.junit.Assert.assertEquals;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
public class VehicleRouteBuilderTest { public class VehicleRouteBuilderTest {
@ -41,6 +41,7 @@ public class VehicleRouteBuilderTest {
@Test(expected=IllegalStateException.class) @Test(expected=IllegalStateException.class)
public void whenPickupIsAddedTwice_throwsException(){ public void whenPickupIsAddedTwice_throwsException(){
Shipment s = mock(Shipment.class); Shipment s = mock(Shipment.class);
when(s.getSize()).thenReturn(Capacity.Builder.newInstance().build());
VehicleRoute.Builder builder = VehicleRoute.Builder.newInstance(mock(Vehicle.class), mock(Driver.class)); VehicleRoute.Builder builder = VehicleRoute.Builder.newInstance(mock(Vehicle.class), mock(Driver.class));
builder.addPickup(s); builder.addPickup(s);
builder.addPickup(s); builder.addPickup(s);
@ -61,10 +62,12 @@ public class VehicleRouteBuilderTest {
public void whenShipmentIsPickedUpThoughButHasNotBeenDeliveredAndRouteIsBuilt_throwsException(){ public void whenShipmentIsPickedUpThoughButHasNotBeenDeliveredAndRouteIsBuilt_throwsException(){
Shipment s = mock(Shipment.class); Shipment s = mock(Shipment.class);
Capacity capacity = Capacity.Builder.newInstance().build(); Capacity capacity = Capacity.Builder.newInstance().build();
Shipment s2 = mock(Shipment.class);
when(s2.getSize()).thenReturn(capacity);
when(s.getSize()).thenReturn(capacity); when(s.getSize()).thenReturn(capacity);
VehicleRoute.Builder builder = VehicleRoute.Builder.newInstance(mock(Vehicle.class), mock(Driver.class)); VehicleRoute.Builder builder = VehicleRoute.Builder.newInstance(mock(Vehicle.class), mock(Driver.class));
builder.addPickup(s); builder.addPickup(s);
builder.addPickup(mock(Shipment.class)); builder.addPickup(s2);
builder.addDelivery(s); builder.addDelivery(s);
builder.build(); builder.build();
} }