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

tested and redesigned StateManager and UpdateLoads

Browse source
This commit is contained in:
oblonski 2014-03-01 12:17:00 +01:00
parent 97819de9f2
commit f6bf46ca9a
6 changed files with 338 additions and 102 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -8,7 +8,7 @@ import java.util.Arrays;
import java.util.Collections;
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.job.Delivery;
import jsprit.core.problem.job.Job;
@ -25,25 +25,23 @@ public class UpdateLoadsTest {
@Test
public void whenVehicleRouteIsEmpty_loadsAtBeginningAndEndShouldBeZero(){
StateManager stateManager = new StateManager(mock(VehicleRoutingProblem.class));
StateManager stateManager = new StateManager(mock(VehicleRoutingTransportCosts.class));
UpdateLoads updateLoads = new UpdateLoads(stateManager);
VehicleRoute route = VehicleRoute.emptyRoute();
updateLoads.informInsertionStarts(Arrays.asList(route), Collections.<Job>emptyList());
assertEquals(0.,stateManager.getRouteState(route, StateFactory.LOAD_AT_BEGINNING).toDouble(),0.1);
assertEquals(0.,stateManager.getRouteState(route, StateFactory.LOAD_AT_END).toDouble(),0.1);
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);
}
@SuppressWarnings("deprecation")
@Test
public void whenVehcicleRouteIsNotEmpty_loadsAtBeginningAndEndShouldBeCalculatedCorrectly(){
StateManager stateManager = new StateManager(mock(VehicleRoutingProblem.class));
StateManager stateManager = new StateManager(mock(VehicleRoutingTransportCosts.class));
UpdateLoads updateLoads = new UpdateLoads(stateManager);
Service service = mock(Service.class);
when(service.getCapacityDemand()).thenReturn(1);
Capacity capacity = Capacity.Builder.newInstance().addDimension(0, 1).build();
when(service.getSize()).thenReturn(capacity);
@ -51,13 +49,13 @@ public class UpdateLoadsTest {
.addService(service).build();
updateLoads.informInsertionStarts(Arrays.asList(route), Collections.<Job>emptyList());
assertEquals(0.,stateManager.getRouteState(route, StateFactory.LOAD_AT_BEGINNING).toDouble(),0.1);
assertEquals(1.,stateManager.getRouteState(route, StateFactory.LOAD_AT_END).toDouble(),0.1);
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(VehicleRoutingProblem.class));
StateManager stateManager = new StateManager(mock(VehicleRoutingTransportCosts.class));
UpdateLoads updateLoads = new UpdateLoads(stateManager);
Service service = mock(Service.class);
@ -68,90 +66,152 @@ public class UpdateLoadsTest {
.addService(service).build();
updateLoads.informInsertionStarts(Arrays.asList(route), Collections.<Job>emptyList());
assertEquals(0.,stateManager.getRouteState(route, StateFactory.LOAD_AT_BEGINNING).toDouble(),0.1);
assertEquals(1.,stateManager.getRouteState(route, StateFactory.LOAD_AT_END).toDouble(),0.1);
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);
}
@SuppressWarnings("deprecation")
@Test
public void whenVehcicleRouteHasTwoActivities_loadsAtBeginningAndEndShouldBeCalculatedCorrectly(){
StateManager stateManager = new StateManager(mock(VehicleRoutingProblem.class));
StateManager stateManager = new StateManager(mock(VehicleRoutingTransportCosts.class));
UpdateLoads updateLoads = new UpdateLoads(stateManager);
Service service = mock(Service.class);
when(service.getCapacityDemand()).thenReturn(1);
when(service.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0, 1).build());
Service service2 = mock(Service.class);
when(service2.getCapacityDemand()).thenReturn(10);
when(service2.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0, 10).build());
VehicleRoute route = VehicleRoute.Builder.newInstance(mock(Vehicle.class), 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).toDouble(),0.1);
assertEquals(11.,stateManager.getRouteState(route, StateFactory.LOAD_AT_END).toDouble(),0.1);
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);
}
@SuppressWarnings("deprecation")
@Test
public void whenVehcicleRouteHasTwoActivities_loadsAtActivitiesShouldBeCalculatedCorrectly(){
StateManager stateManager = new StateManager(mock(VehicleRoutingProblem.class));
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(mock(Vehicle.class), 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.getCapacityDemand()).thenReturn(1);
when(service.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0, 1).build());
Service service2 = mock(Service.class);
when(service2.getCapacityDemand()).thenReturn(10);
when(service2.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0, 10).build());
VehicleRoute route = VehicleRoute.Builder.newInstance(mock(Vehicle.class), mock(Driver.class))
.addService(service).addService(service2).build();
routeActivityVisitor.visit(route);
assertEquals(1.,stateManager.getActivityState(route.getActivities().get(0), StateFactory.LOAD).toDouble(),0.1);
assertEquals(11.,stateManager.getActivityState(route.getActivities().get(1), StateFactory.LOAD).toDouble(),0.1);
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);
}
@SuppressWarnings("deprecation")
@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(mock(Vehicle.class), 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(VehicleRoutingProblem.class));
StateManager stateManager = new StateManager(mock(VehicleRoutingTransportCosts.class));
UpdateLoads updateLoads = new UpdateLoads(stateManager);
Pickup pickup = mock(Pickup.class);
when(pickup.getCapacityDemand()).thenReturn(1);
when(pickup.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0, 1).build());
Delivery delivery = mock(Delivery.class);
when(delivery.getCapacityDemand()).thenReturn(10);
Capacity capacity2 = Capacity.Builder.newInstance().addDimension(0, 10).build();
when(delivery.getSize()).thenReturn(capacity2);
when(delivery.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0, 10).build());
VehicleRoute route = VehicleRoute.Builder.newInstance(mock(Vehicle.class), 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).toDouble(),0.1);
assertEquals(1.,stateManager.getRouteState(route, StateFactory.LOAD_AT_END).toDouble(),0.1);
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(mock(Vehicle.class), 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);
}
@SuppressWarnings("deprecation")
@Test
public void whenVehcicleRouteHasPickupAndDelivery_loadsAtActivitiesShouldBeCalculatedCorrectly(){
StateManager stateManager = new StateManager(mock(VehicleRoutingProblem.class));
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.getCapacityDemand()).thenReturn(1);
when(pickup.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0, 1).build());
Delivery delivery = mock(Delivery.class);
when(delivery.getCapacityDemand()).thenReturn(10);
Capacity capacity2 = Capacity.Builder.newInstance().addDimension(0, 10).build();
when(delivery.getSize()).thenReturn(capacity2);
@ -161,29 +221,54 @@ public class UpdateLoadsTest {
updateLoads.informInsertionStarts(Arrays.asList(route), Collections.<Job>emptyList());
routeActivityVisitor.visit(route);
assertEquals(11.,stateManager.getActivityState(route.getActivities().get(0), StateFactory.LOAD).toDouble(),0.1);
assertEquals(1.,stateManager.getActivityState(route.getActivities().get(1), StateFactory.LOAD).toDouble(),0.1);
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);
}
@SuppressWarnings("deprecation")
@Test
public void whenPickupIsInsertedIntoVehcicleRouteWithPickupAndDelivery_loadsAtBeginningAndEndShouldBeCalculatedCorrectly(){
StateManager stateManager = new StateManager(mock(VehicleRoutingProblem.class));
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.getCapacityDemand()).thenReturn(1);
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(mock(Vehicle.class), 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);
when(delivery.getCapacityDemand()).thenReturn(10);
Capacity capacity2 = Capacity.Builder.newInstance().addDimension(0, 10).build();
when(delivery.getSize()).thenReturn(capacity2);
Pickup pickup2insert = mock(Pickup.class);
when(pickup2insert.getCapacityDemand()).thenReturn(2);
when(pickup2insert.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0, 2).build());
VehicleRoute route = VehicleRoute.Builder.newInstance(mock(Vehicle.class), mock(Driver.class))
.addService(pickup).addService(delivery).build();
@ -191,29 +276,56 @@ public class UpdateLoadsTest {
updateLoads.informInsertionStarts(Arrays.asList(route), Collections.<Job>emptyList());
updateLoads.informJobInserted(pickup2insert, route, 0., 0.);
assertEquals(10.,stateManager.getRouteState(route, StateFactory.LOAD_AT_BEGINNING).toDouble(),0.1);
assertEquals(3.,stateManager.getRouteState(route, StateFactory.LOAD_AT_END).toDouble(),0.1);
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);
}
@SuppressWarnings("deprecation")
@Test
public void whenDeliveryIsInsertedIntoVehcicleRouteWithPickupAndDelivery_loadsAtBeginningAndEndShouldBeCalculatedCorrectly(){
StateManager stateManager = new StateManager(mock(VehicleRoutingProblem.class));
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.getCapacityDemand()).thenReturn(1);
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(mock(Vehicle.class), 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);
when(delivery.getCapacityDemand()).thenReturn(10);
Capacity size = Capacity.Builder.newInstance().addDimension(0, 10).build();
when(delivery.getSize()).thenReturn(size);
Delivery delivery2insert = mock(Delivery.class);
when(delivery2insert.getCapacityDemand()).thenReturn(20);
Capacity size2 = Capacity.Builder.newInstance().addDimension(0, 20).build();
when(delivery2insert.getSize()).thenReturn(size2);
@ -223,8 +335,39 @@ public class UpdateLoadsTest {
updateLoads.informInsertionStarts(Arrays.asList(route), Collections.<Job>emptyList());
updateLoads.informJobInserted(delivery2insert, route, 0., 0.);
assertEquals(30.,stateManager.getRouteState(route, StateFactory.LOAD_AT_BEGINNING).toDouble(),0.1);
assertEquals(1.,stateManager.getRouteState(route, StateFactory.LOAD_AT_END).toDouble(),0.1);
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(mock(Vehicle.class), 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);
}
}

47
jsprit-core/src/test/java/jsprit/core/problem/CapacityTest.java
View file

@ -230,6 +230,28 @@ public class CapacityTest {
assertFalse(cap2.isLessOrEqual(cap1));
}
@Test
public void whenOneCapIsBiggerThanAnother_greaterOrEqualShouldReturnTrue(){
Capacity cap1 = Capacity.Builder.newInstance().addDimension(0, 2).addDimension(1, 3).addDimension(2, 4).build();
Capacity cap2 = Capacity.Builder.newInstance().addDimension(0, 2).addDimension(1, 4).addDimension(2, 4).build();
assertTrue(cap2.isGreaterOrEqual(cap1));
}
@Test
public void whenOneCapIsBiggerThanAnother_greaterOrEqualShouldReturnTrue_v2(){
Capacity cap1 = Capacity.Builder.newInstance().addDimension(0, 2).addDimension(1, 3).addDimension(2, 4).build();
//which is zero-cap
Capacity cap2 = Capacity.Builder.newInstance().build();
assertTrue(cap1.isGreaterOrEqual(cap2));
}
@Test
public void whenOneCapIsEqualToAnother_greaterOrEqualShouldReturnTrue(){
Capacity cap1 = Capacity.Builder.newInstance().addDimension(0, 2).addDimension(1, 3).addDimension(2, 4).build();
Capacity cap2 = Capacity.Builder.newInstance().addDimension(0, 2).addDimension(1, 3).addDimension(2, 4).build();
assertTrue(cap2.isGreaterOrEqual(cap1));
}
@Test
public void whenAddingTwo_itShouldReturnCorrectCap(){
int wheelChairSpace = 0;
@ -267,4 +289,29 @@ public class CapacityTest {
assertEquals(-4,inverted.get(2));
}
@Test
public void whenDeterminingTheMaximumOfTwoCapacities_itShouldReturnCapWithMaxOfEachDimension(){
Capacity cap1 = Capacity.Builder.newInstance().addDimension(0, 3).addDimension(1, 3).build();
Capacity cap2 = Capacity.Builder.newInstance().addDimension(0, 2).addDimension(1, 4).build();
assertEquals(3,Capacity.max(cap1,cap2).get(0));
assertEquals(4,Capacity.max(cap1,cap2).get(1));
}
@Test
public void whenDeterminingTheMaximumOfTwoCapacities_itShouldReturnCapWithMaxOfEachDimension_v2(){
Capacity cap1 = Capacity.Builder.newInstance().addDimension(0, 1).addDimension(1, 3).build();
Capacity cap2 = Capacity.Builder.newInstance().addDimension(0, 2).addDimension(1, 4).build();
assertEquals(2,Capacity.max(cap1,cap2).get(0));
assertEquals(4,Capacity.max(cap1,cap2).get(1));
}
@Test
public void whenDeterminingTheMaximumOfTwoCapacities_itShouldReturnCapWithMaxOfEachDimension_v3(){
Capacity cap1 = Capacity.Builder.newInstance().addDimension(0, 1).addDimension(1, 3).addDimension(2, 3).build();
Capacity cap2 = Capacity.Builder.newInstance().addDimension(0, 2).addDimension(1, 4).build();
assertEquals(2,Capacity.max(cap1,cap2).get(0));
assertEquals(4,Capacity.max(cap1,cap2).get(1));
assertEquals(3,Capacity.max(cap1,cap2).get(2));
}
}