add and test constraint violation checks

jsprit-core/src/main/java/jsprit/core/analysis/SolutionAnalyser.java

@@ -17,25 +17,20 @@
 
 package jsprit.core.analysis;
 
-import jsprit.core.algorithm.state.InternalStates;
+import jsprit.core.algorithm.state.*;
-import jsprit.core.algorithm.state.StateId;
-import jsprit.core.algorithm.state.StateManager;
-import jsprit.core.algorithm.state.StateUpdater;
 import jsprit.core.problem.Capacity;
 import jsprit.core.problem.VehicleRoutingProblem;
-import jsprit.core.problem.constraint.ConstraintManager;
-import jsprit.core.problem.constraint.HardActivityConstraint;
-import jsprit.core.problem.constraint.HardRouteConstraint;
 import jsprit.core.problem.solution.VehicleRoutingProblemSolution;
 import jsprit.core.problem.solution.route.VehicleRoute;
-import jsprit.core.problem.solution.route.activity.ActivityVisitor;
+import jsprit.core.problem.solution.route.activity.*;
-import jsprit.core.problem.solution.route.activity.End;
-import jsprit.core.problem.solution.route.activity.Start;
-import jsprit.core.problem.solution.route.activity.TourActivity;
 import jsprit.core.util.ActivityTimeTracker;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
 
 import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 
 /**
  *
@@ -51,25 +46,87 @@ public class SolutionAnalyser {
 
     }
 
-//    public static class ViolatedRouteConstraints {
+    private static class BackhaulAndShipmentUpdater implements StateUpdater, ActivityVisitor {
-//
+
-//        private List<HardRouteConstraint> hardRouteConstraints = new ArrayList<HardRouteConstraint>();
+        private final StateId backhaul_id;
-//
+
-//        public List<HardRouteConstraint> getHardRouteConstraints() {
+        private final StateId shipment_id;
-//            return hardRouteConstraints;
+
-//        }
+        private final StateManager stateManager;
-//
+
-//    }
+        private Map<String,PickupShipment> openShipments;
-//
+
-//    public static class ViolatedActivityConstraints {
+        private VehicleRoute route;
-//
+
-//        private List<HardActivityConstraint> hardConstraints = new ArrayList<HardActivityConstraint>();
+        private Boolean shipmentConstraintOnRouteViolated;
-//
+
-//        public List<HardActivityConstraint> getHardActivityConstraints() {
+        private Boolean backhaulConstraintOnRouteViolated;
-//            return hardConstraints;
+
-//        }
+        private boolean pickupOccured;
-//
+
-//    }
+        private BackhaulAndShipmentUpdater(StateId backhaul_id, StateId shipment_id, StateManager stateManager) {
+            this.stateManager = stateManager;
+            this.backhaul_id = backhaul_id;
+            this.shipment_id = shipment_id;
+        }
+
+        @Override
+        public void begin(VehicleRoute route) {
+            this.route = route;
+            openShipments = new HashMap<String, PickupShipment>();
+            pickupOccured = false;
+            shipmentConstraintOnRouteViolated = false;
+            backhaulConstraintOnRouteViolated = false;
+        }
+
+        @Override
+        public void visit(TourActivity activity) {
+            //shipment
+            if(activity instanceof PickupShipment){
+                openShipments.put(((PickupShipment) activity).getJob().getId(),(PickupShipment)activity);
+            }
+            else if(activity instanceof DeliverShipment){
+                String jobId = ((DeliverShipment) activity).getJob().getId();
+                if(!openShipments.containsKey(jobId)){
+                    //deliverShipment without pickupShipment
+                    stateManager.putActivityState(activity,shipment_id,true);
+                    shipmentConstraintOnRouteViolated = true;
+                }
+                else {
+                    PickupShipment removed = openShipments.remove(jobId);
+                    stateManager.putActivityState(removed,shipment_id,false);
+                    stateManager.putActivityState(activity,shipment_id,false);
+                }
+            }
+            else stateManager.putActivityState(activity,shipment_id,false);
+
+            //backhaul
+            if(activity instanceof DeliverService && pickupOccured){
+                stateManager.putActivityState(activity,backhaul_id,true);
+                backhaulConstraintOnRouteViolated = true;
+            }
+            else{
+                if(activity instanceof PickupService || activity instanceof ServiceActivity || activity instanceof PickupShipment){
+                    pickupOccured = true;
+                    stateManager.putActivityState(activity,backhaul_id,false);
+                }
+                else stateManager.putActivityState(activity,backhaul_id,false);
+            }
+        }
+
+        @Override
+        public void finish() {
+            //shipment
+            //pickups without deliveries
+            for(TourActivity act : openShipments.values()){
+                stateManager.putActivityState(act,shipment_id,true);
+                shipmentConstraintOnRouteViolated = true;
+            }
+            stateManager.putRouteState(route,shipment_id,shipmentConstraintOnRouteViolated);
+            //backhaul
+            stateManager.putRouteState(route,backhaul_id,backhaulConstraintOnRouteViolated);
+        }
+    }
 
     private static class SumUpActivityTimes implements StateUpdater, ActivityVisitor {
 
@@ -190,68 +247,7 @@ public class SolutionAnalyser {
         }
     }
 
-//    private static class ConstraintViolationUpdater implements StateUpdater, ActivityVisitor {
+    private static final Logger log = LogManager.getLogger(SolutionAnalyser.class);
-//
-//        private ConstraintManager constraintManager;
-//
-//        private StateManager stateManager;
-//
-//        private StateId violated_route_constraints_id;
-//
-//        private VehicleRoute route;
-//
-//        private List<HardRouteConstraint> hardRouteConstraints;
-//
-//        private Set<String> examinedJobs = new HashSet<String>();
-//
-////        ViolatedRouteConstraints violatedRouteConstraints = new ViolatedRouteConstraints();
-//
-//        private ConstraintViolationUpdater(ConstraintManager constraintManager, StateManager stateManager, StateId violated_route_constraints_id) {
-//            this.constraintManager = constraintManager;
-//            this.stateManager = stateManager;
-//            this.violated_route_constraints_id = violated_route_constraints_id;
-//            hardRouteConstraints = getHardRouteConstraints(constraintManager);
-//        }
-//
-//        private List<HardRouteConstraint> getHardRouteConstraints(ConstraintManager constraintManager) {
-//            List<HardRouteConstraint> constraints = new ArrayList<HardRouteConstraint>();
-//            for(Constraint c : constraintManager.getConstraints()){
-//                if(c instanceof HardRouteConstraint){
-//                    constraints.add((HardRouteConstraint) c);
-//                }
-//            }
-//            return constraints;
-//        }
-//
-//        @Override
-//        public void begin(VehicleRoute route) {
-//            this.route = route;
-//            examinedJobs.clear();
-////            violatedRouteConstraints.getHardRouteConstraints().clear();
-//        }
-//
-//        @Override
-//        public void visit(TourActivity activity) {
-//            //hard route constraints
-//            if(activity instanceof TourActivity.JobActivity){
-//                Job job = ((TourActivity.JobActivity) activity).getJob();
-//                if(!examinedJobs.contains(job.getId())){
-//                    examinedJobs.add(job.getId());
-//                    JobInsertionContext iContext = new JobInsertionContext(route,job,route.getVehicle(),route.getDriver(),route.getDepartureTime());
-//                    for(HardRouteConstraint hardRouteConstraint : hardRouteConstraints){
-//                        boolean fulfilled = hardRouteConstraint.fulfilled(iContext);
-//                        if(!fulfilled) violatedRouteConstraints.getHardRouteConstraints().add(hardRouteConstraint);
-//                    }
-//                }
-//            }
-//
-//        }
-//
-//        @Override
-//        public void finish() {
-//            stateManager.putRouteState(route,violated_route_constraints_id,violatedRouteConstraints);
-//        }
-//    }
 
     private VehicleRoutingProblem vrp;
 
@@ -259,8 +255,6 @@ public class SolutionAnalyser {
 
     private StateManager stateManager;
 
-    private ConstraintManager constraintManager;
-
     private DistanceCalculator distanceCalculator;
 
     private final StateId waiting_time_id;
@@ -273,18 +267,15 @@ public class SolutionAnalyser {
 
     private final StateId too_late_id;
 
-//    private final StateId violated_constraint_id;
+    private final StateId shipment_id;
+
+    private final StateId backhaul_id;
 
     private ActivityTimeTracker.ActivityPolicy activityPolicy;
 
-    private List<HardRouteConstraint> hardRouteConstraints;
-
-    private List<HardActivityConstraint> hardActivityConstraints;
 
     private final VehicleRoutingProblemSolution working_solution;
 
-//    private final VehicleRoutingProblemSolution original_solution;
-
     public SolutionAnalyser(VehicleRoutingProblem vrp, VehicleRoutingProblemSolution solution, DistanceCalculator distanceCalculator) {
         this.vrp = vrp;
 //        this.original_solution = VehicleRoutingProblemSolution.copyOf(solution);
@@ -294,108 +285,29 @@ public class SolutionAnalyser {
         this.stateManager.updateTimeWindowStates();
         this.stateManager.updateLoadStates();
         this.stateManager.updateSkillStates();
-        this.constraintManager = new ConstraintManager(vrp,stateManager);
+        activityPolicy = ActivityTimeTracker.ActivityPolicy.AS_SOON_AS_TIME_WINDOW_OPENS;
+        this.stateManager.addStateUpdater(new UpdateActivityTimes(vrp.getTransportCosts(),activityPolicy));
+        this.stateManager.addStateUpdater(new UpdateVariableCosts(vrp.getActivityCosts(),vrp.getTransportCosts(),stateManager));
         this.distanceCalculator = distanceCalculator;
         waiting_time_id = stateManager.createStateId("waiting-time");
         transport_time_id = stateManager.createStateId("transport-time");
         service_time_id = stateManager.createStateId("service-time");
         distance_id = stateManager.createStateId("distance");
         too_late_id = stateManager.createStateId("too-late");
-//        violated_constraint_id = stateManager.createStateId("violated-constraints");
+        shipment_id = stateManager.createStateId("shipment");
-        activityPolicy = ActivityTimeTracker.ActivityPolicy.AS_SOON_AS_TIME_WINDOW_OPENS;
+        backhaul_id = stateManager.createStateId("backhaul");
-//        if(stateManager.timeWindowUpdateIsActivated()){
-//            activityPolicy = ActivityTimeTracker.ActivityPolicy.AS_SOON_AS_TIME_WINDOW_OPENS;
-//        }
         stateManager.addStateUpdater(new SumUpActivityTimes(waiting_time_id, transport_time_id, service_time_id,too_late_id , stateManager, activityPolicy));
         stateManager.addStateUpdater(new DistanceUpdater(distance_id,stateManager,distanceCalculator));
-//        hardRouteConstraints = getHardRouteConstraints(constraintManager);
+        stateManager.addStateUpdater(new BackhaulAndShipmentUpdater(backhaul_id,shipment_id,stateManager));
-//        hardActivityConstraints = getHardActivityConstrains(constraintManager);
         refreshStates();
     }
 
-//    private List<HardActivityConstraint> getHardActivityConstrains(ConstraintManager constraintManager) {
-//        List<HardActivityConstraint> constraints = new ArrayList<HardActivityConstraint>();
-//        for(Constraint c : constraintManager.getConstraints()){
-//            if(c instanceof HardActivityConstraint){
-//                constraints.add((HardActivityConstraint) c);
-//            }
-//        }
-//        return constraints;
-//    }
 
     private void refreshStates(){
         stateManager.clear();
         stateManager.informInsertionStarts(routes,null);
-//        checkConstraintViolation();
     }
 
-//    private void checkConstraintViolation() {
-//        for(VehicleRoute route : routes){
-//            Set<HardRouteConstraint> unique = new HashSet<HardRouteConstraint>();
-//            Set<String> examinedJobIds = new HashSet<String>();
-//            TourActivity actBeforePrevAct = route.getStart();
-//            TourActivity prevAct = null;
-//            JobInsertionContext prevJobInsertionContext = null;
-//            for(TourActivity act : route.getActivities()){
-//                if(prevAct == null){
-//                    prevAct = act;
-//                    prevJobInsertionContext = createContext(route,act);
-//                    continue;
-//                }
-//                //examine hard route constraints
-//                if(!examinedJobIds.contains(prevJobInsertionContext.getJob().getId())){
-//                    examinedJobIds.add(prevJobInsertionContext.getJob().getId());
-//                    for(HardRouteConstraint hardRouteConstraint : hardRouteConstraints){
-//                        boolean fulfilled = hardRouteConstraint.fulfilled(prevJobInsertionContext);
-//                        if(!fulfilled) unique.add(hardRouteConstraint);
-//                    }
-//                }
-//
-//                //exmaine hard activity constraints
-//                examineActivityConstraints(prevJobInsertionContext, actBeforePrevAct, prevAct, act);
-//
-//                actBeforePrevAct = prevAct;
-//                prevAct = act;
-//                prevJobInsertionContext = createContext(route,act);
-//            }
-//            examineActivityConstraints(prevJobInsertionContext,actBeforePrevAct,prevAct,route.getEnd());
-//
-////            ViolatedRouteConstraints violatedRouteConstraints = new ViolatedRouteConstraints();
-////            violatedRouteConstraints.getHardRouteConstraints().addAll(unique);
-////            stateManager.putRouteState(route, violated_constraint_id,violatedRouteConstraints);
-//        }
-//    }
-
-//    private void examineActivityConstraints(JobInsertionContext prevJobInsertionContext, TourActivity actBeforePrevAct, TourActivity prevAct, TourActivity act) {
-//        ViolatedActivityConstraints violatedActivityConstraints = new ViolatedActivityConstraints();
-//        for(HardActivityConstraint activityConstraint : hardActivityConstraints){
-//            HardActivityConstraint.ConstraintsStatus status =
-//                    activityConstraint.fulfilled(prevJobInsertionContext,actBeforePrevAct,prevAct,act,actBeforePrevAct.getEndTime());
-//            if(!status.equals(HardActivityConstraint.ConstraintsStatus.FULFILLED)){
-//                violatedActivityConstraints.getHardActivityConstraints().add(activityConstraint);
-//            }
-//        }
-//        stateManager.putActivityState(prevAct, violated_constraint_id,violatedActivityConstraints);
-//    }
-
-//    private JobInsertionContext createContext(VehicleRoute route, TourActivity act) {
-//        if(act instanceof TourActivity.JobActivity){
-//            return new JobInsertionContext(route,((TourActivity.JobActivity) act).getJob(),route.getVehicle(),route.getDriver(),route.getDepartureTime());
-//        }
-//        throw new IllegalStateException("act not a job activity. this should not be currently");
-//    }
-//
-//    private List<HardRouteConstraint> getHardRouteConstraints(ConstraintManager constraintManager) {
-//        List<HardRouteConstraint> constraints = new ArrayList<HardRouteConstraint>();
-//        for(Constraint c : constraintManager.getConstraints()){
-//            if(c instanceof HardRouteConstraint){
-//                constraints.add((HardRouteConstraint) c);
-//            }
-//        }
-//        return constraints;
-//    }
-
-//
 //
 //    public void informRouteChanged(VehicleRoute route){
 //        update(route);
@@ -408,6 +320,7 @@ public class SolutionAnalyser {
      * @return load at start location of specified route
      */
     public Capacity getLoadAtBeginning(VehicleRoute route){
+        if(route == null) throw new IllegalStateException("route is missing.");
         return stateManager.getRouteState(route, InternalStates.LOAD_AT_BEGINNING,Capacity.class);
     }
 
@@ -416,6 +329,7 @@ public class SolutionAnalyser {
      * @return load at end location of specified route
      */
     public Capacity getLoadAtEnd(VehicleRoute route){
+        if(route == null) throw new IllegalStateException("route is missing.");
         return stateManager.getRouteState(route, InternalStates.LOAD_AT_END,Capacity.class);
     }
 
@@ -424,6 +338,7 @@ public class SolutionAnalyser {
      * @return max load of specified route, i.e. for each capacity dimension the max value.
      */
     public Capacity getMaxLoad(VehicleRoute route){
+        if(route == null) throw new IllegalStateException("route is missing.");
         return stateManager.getRouteState(route, InternalStates.MAXLOAD,Capacity.class);
     }
 
@@ -435,19 +350,31 @@ public class SolutionAnalyser {
      * Returns null if no load can be found.
      */
     public Capacity getLoadRightAfterActivity(TourActivity activity, VehicleRoute route){
+        if(route == null) throw new IllegalStateException("route is missing.");
+        if(activity == null) throw new IllegalStateException("activity is missing.");
         if(activity instanceof Start) return getLoadAtBeginning(route);
         if(activity instanceof End) return getLoadAtEnd(route);
+        verifyThatRouteContainsAct(activity, route);
         return stateManager.getActivityState(activity, InternalStates.LOAD, Capacity.class);
     }
 
+    private void verifyThatRouteContainsAct(TourActivity activity, VehicleRoute route) {
+        if(!route.getTourActivities().hasActivity(activity)){
+            throw new IllegalStateException("specified route does not contain specified activity " + activity);
+        }
+    }
+
     /**
      * @param activity to get the load from (before activity)
      * @return load just before the specified activity. If act is Start, it returns the load atBeginning of the specified
      * route. If act is End, it returns the load atEnd of specified route.
      */
     public Capacity getLoadJustBeforeActivity(TourActivity activity, VehicleRoute route){
+        if(route == null) throw new IllegalStateException("route is missing.");
+        if(activity == null) throw new IllegalStateException("activity is missing.");
         if(activity instanceof Start) return getLoadAtBeginning(route);
         if(activity instanceof End) return getLoadAtEnd(route);
+        verifyThatRouteContainsAct(activity, route);
         Capacity afterAct = stateManager.getActivityState(activity, InternalStates.LOAD,Capacity.class);
         if(afterAct != null && activity.getSize() != null){
             return Capacity.subtract(afterAct, activity.getSize());
@@ -461,6 +388,7 @@ public class SolutionAnalyser {
      * @return the capacity violation on this route, i.e. maxLoad - vehicleCapacity
      */
     public Capacity getCapacityViolation(VehicleRoute route){
+        if(route == null) throw new IllegalStateException("route is missing.");
         Capacity maxLoad = getMaxLoad(route);
         return Capacity.max(Capacity.Builder.newInstance().build(),Capacity.subtract(maxLoad,route.getVehicle().getType().getCapacityDimensions()));
     }
@@ -472,6 +400,7 @@ public class SolutionAnalyser {
      * [[dimIndex=0][dimValue=0][dimIndex=1][dimValue=4]]
      */
     public Capacity getCapacityViolationAtBeginning(VehicleRoute route){
+        if(route == null) throw new IllegalStateException("route is missing.");
         Capacity atBeginning = getLoadAtBeginning(route);
         return Capacity.max(Capacity.Builder.newInstance().build(),Capacity.subtract(atBeginning,route.getVehicle().getType().getCapacityDimensions()));
     }
@@ -483,6 +412,7 @@ public class SolutionAnalyser {
      * [[dimIndex=0][dimValue=0][dimIndex=1][dimValue=4]]
      */
     public Capacity getCapacityViolationAtEnd(VehicleRoute route){
+        if(route == null) throw new IllegalStateException("route is missing.");
         Capacity atEnd = getLoadAtEnd(route);
         return Capacity.max(Capacity.Builder.newInstance().build(),Capacity.subtract(atEnd,route.getVehicle().getType().getCapacityDimensions()));
     }
@@ -495,6 +425,8 @@ public class SolutionAnalyser {
      * [[dimIndex=0][dimValue=0][dimIndex=1][dimValue=4]]
      */
     public Capacity getCapacityViolationAfterActivity(TourActivity activity, VehicleRoute route){
+        if(route == null) throw new IllegalStateException("route is missing.");
+        if(activity == null) throw new IllegalStateException("activity is missing.");
         Capacity afterAct = getLoadRightAfterActivity(activity,route);
         return Capacity.max(Capacity.Builder.newInstance().build(),Capacity.subtract(afterAct,route.getVehicle().getType().getCapacityDimensions()));
     }
@@ -504,6 +436,7 @@ public class SolutionAnalyser {
      * @return time violation of route, i.e. sum of individual activity time window violations.
      */
     public Double getTimeWindowViolation(VehicleRoute route){
+        if(route == null) throw new IllegalStateException("route is missing.");
         return stateManager.getRouteState(route,too_late_id,Double.class);
     }
 
@@ -513,27 +446,48 @@ public class SolutionAnalyser {
      * @return time violation of activity
      */
     public Double getTimeWindowViolationAtActivity(TourActivity activity, VehicleRoute route){
+        if(route == null) throw new IllegalStateException("route is missing.");
+        if(activity == null) throw new IllegalStateException("activity is missing.");
         return Math.max(0,activity.getArrTime()-activity.getTheoreticalLatestOperationStartTime());
     }
 
     public Boolean skillConstraintIsViolated(VehicleRoute route){
+        if(route == null) throw new IllegalStateException("route is missing.");
         return null;
     }
 
     public Boolean skillConstraintIsViolatedAtActivity(TourActivity activity, VehicleRoute route){
+        if(route == null) throw new IllegalStateException("route is missing.");
+        if(activity == null) throw new IllegalStateException("activity is missing.");
+        verifyThatRouteContainsAct(activity, route);
         return null;
     }
 
     public Boolean backhaulConstraintIsViolated(VehicleRoute route){
-        return null;
+        return stateManager.getRouteState(route,backhaul_id,Boolean.class);
+    }
+
+    public Boolean backhaulConstraintIsViolatedAtActivity(TourActivity activity, VehicleRoute route){
+        if(route == null) throw new IllegalStateException("route is missing.");
+        if(activity == null) throw new IllegalStateException("activity is missing.");
+        if(activity instanceof Start) return false;
+        if(activity instanceof End) return false;
+        verifyThatRouteContainsAct(activity, route);
+        return stateManager.getActivityState(activity,backhaul_id,Boolean.class);
     }
 
     public Boolean shipmentConstraintIsViolated(VehicleRoute route){
-        return null;
+        if(route == null) throw new IllegalStateException("route is missing.");
+        return stateManager.getRouteState(route,shipment_id,Boolean.class);
     }
 
     public Boolean shipmentConstraintIsViolatedAtActivity(TourActivity activity, VehicleRoute route){
-        return null;
+        if(route == null) throw new IllegalStateException("route is missing.");
+        if(activity == null) throw new IllegalStateException("activity is missing.");
+        if(activity instanceof Start) return false;
+        if(activity instanceof End) return false;
+        verifyThatRouteContainsAct(activity, route);
+        return stateManager.getActivityState(activity,shipment_id,Boolean.class);
     }
 
 
@@ -543,6 +497,7 @@ public class SolutionAnalyser {
      * @return operation time of this route, i.e. endTime - startTime of specified route
      */
     public Double getOperationTime(VehicleRoute route){
+        if(route == null) throw new IllegalStateException("route is missing.");
         return route.getEnd().getArrTime() - route.getStart().getEndTime();
     }
 
@@ -552,6 +507,7 @@ public class SolutionAnalyser {
      * Returns null if no waiting time value exists for the specified route
      */
     public Double getWaitingTime(VehicleRoute route){
+        if(route == null) throw new IllegalStateException("route is missing.");
         return stateManager.getRouteState(route, waiting_time_id, Double.class);
     }
 
@@ -560,6 +516,7 @@ public class SolutionAnalyser {
      * @return total transport time of specified route. Returns null if no time value exists for the specified route.
      */
     public Double getTransportTime(VehicleRoute route){
+        if(route == null) throw new IllegalStateException("route is missing.");
         return stateManager.getRouteState(route, transport_time_id, Double.class);
     }
 
@@ -568,6 +525,7 @@ public class SolutionAnalyser {
      * @return total service time of specified route. Returns null if no time value exists for specified route.
      */
     public Double getServiceTime(VehicleRoute route){
+        if(route == null) throw new IllegalStateException("route is missing.");
         return stateManager.getRouteState(route, service_time_id, Double.class);
     }
 
@@ -577,6 +535,8 @@ public class SolutionAnalyser {
      * vrp.getTransportCosts().getTransportCost(fromId,toId,...)
      */
     public Double getVariableTransportCosts(VehicleRoute route){
+        if(route == null) throw new IllegalStateException("route is missing.");
+
         return stateManager.getRouteState(route,InternalStates.COSTS,Double.class);
     }
 
@@ -585,26 +545,10 @@ public class SolutionAnalyser {
      * @return fixed costs of route, i.e. fixed costs of employed vehicle on this route.
      */
     public Double getFixedCosts(VehicleRoute route){
+        if(route == null) throw new IllegalStateException("route is missing.");
         return route.getVehicle().getType().getVehicleCostParams().fix;
     }
 
-//    public ViolatedRouteConstraints getViolatedHardConstraints(VehicleRoute route){
-//        return stateManager.getRouteState(route, violated_constraint_id,ViolatedRouteConstraints.class);
-//    }
-
-//    public Map<SoftRouteConstraint,Double> getViolatedSoftConstraints(VehicleRoute route){
-//        return null;
-//    }
-
-//    public ViolatedActivityConstraints getViolatedHardConstraintsAtActivity(TourActivity activity, VehicleRoute route){
-//        if(activity instanceof Start) return new ViolatedActivityConstraints();
-//        if(activity instanceof End) return new ViolatedActivityConstraints();
-//        return stateManager.getActivityState(activity,violated_constraint_id,ViolatedActivityConstraints.class);
-//    }
-
-//    public Map<SoftRouteConstraint,Double> getViolatedSoftConstraint(VehicleRoute route){
-//        return null;
-//    }
 
     /**
      * @param activity to get the variable transport costs from
@@ -613,8 +557,11 @@ public class SolutionAnalyser {
      * If activity is start, it returns 0.. If it is end, it returns .getVariableTransportCosts(route).
      */
     public Double getVariableTransportCostsAtActivity(TourActivity activity, VehicleRoute route){
+        if(route == null) throw new IllegalStateException("route is missing.");
+        if(activity == null) throw new IllegalStateException("activity is missing.");
         if(activity instanceof Start) return 0.;
         if(activity instanceof End) return getVariableTransportCosts(route);
+        verifyThatRouteContainsAct(activity, route);
         return stateManager.getActivityState(activity,InternalStates.COSTS,Double.class);
     }
 
@@ -624,6 +571,8 @@ public class SolutionAnalyser {
      * @return waiting time at activity
      */
     public Double getWaitingTimeAtActivity(TourActivity activity, VehicleRoute route){
+        if(route == null) throw new IllegalStateException("route is missing.");
+        if(activity == null) throw new IllegalStateException("activity is missing.");
         double waitingTime = 0.;
         if(activityPolicy.equals(ActivityTimeTracker.ActivityPolicy.AS_SOON_AS_TIME_WINDOW_OPENS)){
             waitingTime = Math.max(0,activity.getTheoreticalEarliestOperationStartTime()-activity.getArrTime());
@@ -636,6 +585,8 @@ public class SolutionAnalyser {
      * @return time too late
      */
     public Double getLateArrivalTimesAtActivity(TourActivity activity, VehicleRoute route){
+        if(route == null) throw new IllegalStateException("route is missing.");
+        if(activity == null) throw new IllegalStateException("activity is missing.");
         double tooLate = 0.;
         if(activityPolicy.equals(ActivityTimeTracker.ActivityPolicy.AS_SOON_AS_TIME_WINDOW_OPENS)){
             tooLate = Math.max(0,activity.getArrTime()-activity.getTheoreticalLatestOperationStartTime());
@@ -648,6 +599,7 @@ public class SolutionAnalyser {
      * @return time too late, i.e. sum of late time of activities
      */
     public Double getLateArrivalTimes(VehicleRoute route){
+        if(route == null) throw new IllegalStateException("route is missing.");
         return stateManager.getRouteState(route,too_late_id,Double.class);
     }
 
@@ -656,6 +608,7 @@ public class SolutionAnalyser {
      * @return total distance of route
      */
     public Double getDistance(VehicleRoute route){
+        if(route == null) throw new IllegalStateException("route is missing.");
         return stateManager.getRouteState(route, distance_id, Double.class);
     }
 
@@ -664,8 +617,11 @@ public class SolutionAnalyser {
      * @return distance at activity
      */
     public Double getDistanceAtActivity(TourActivity activity, VehicleRoute route){
+        if(route == null) throw new IllegalStateException("route is missing.");
+        if(activity == null) throw new IllegalStateException("activity is missing.");
         if(activity instanceof Start) return 0.;
         if(activity instanceof End) return getDistance(route);
+        verifyThatRouteContainsAct(activity, route);
         return stateManager.getActivityState(activity, distance_id, Double.class);
     }
 

jsprit-core/src/test/java/jsprit/core/analysis/SolutionAnalyserTest.java

@@ -18,12 +18,8 @@
 package jsprit.core.analysis;
 
 
-import jsprit.core.algorithm.VehicleRoutingAlgorithm;
-import jsprit.core.algorithm.VehicleRoutingAlgorithmBuilder;
-import jsprit.core.algorithm.state.StateManager;
 import jsprit.core.problem.Capacity;
 import jsprit.core.problem.VehicleRoutingProblem;
-import jsprit.core.problem.constraint.ConstraintManager;
 import jsprit.core.problem.job.Delivery;
 import jsprit.core.problem.job.Pickup;
 import jsprit.core.problem.job.Service;
@@ -38,11 +34,11 @@ import jsprit.core.problem.vehicle.VehicleTypeImpl;
 import jsprit.core.reporting.SolutionPrinter;
 import jsprit.core.util.Coordinate;
 import jsprit.core.util.ManhattanCosts;
-import jsprit.core.util.Solutions;
 import junit.framework.Assert;
 import org.junit.Before;
 import org.junit.Test;
 
+import java.util.Arrays;
 import java.util.Iterator;
 
 import static org.junit.Assert.*;
@@ -53,9 +49,6 @@ public class SolutionAnalyserTest {
 
     private VehicleRoutingProblemSolution solution;
 
-    private StateManager stateManager;
-
-    private ConstraintManager constraintManager;
 
     private SolutionAnalyser.DistanceCalculator distanceCalculator;
 
@@ -93,18 +86,13 @@ public class SolutionAnalyserTest {
         vrpBuilder.setRoutingCost(new ManhattanCosts(vrpBuilder.getLocations()));
         vrp = vrpBuilder.build();
 
-        VehicleRoutingAlgorithmBuilder vraBuilder = new VehicleRoutingAlgorithmBuilder(vrp,"src/test/resources/algorithmConfig.xml");
+        VehicleRoute route1 = VehicleRoute.Builder.newInstance(vehicle).setJobActivityFactory(vrp.getJobActivityFactory())
-        vraBuilder.addDefaultCostCalculators();
+                .addService(s1).addPickup(shipment1).addDelivery(shipment1).addService(s2).build();
-        vraBuilder.addCoreConstraints();
-        stateManager = new StateManager(vrp);
-        stateManager.updateLoadStates();
-        constraintManager = new ConstraintManager(vrp,stateManager);
-        vraBuilder.setStateAndConstraintManager(stateManager,constraintManager);
 
-        VehicleRoutingAlgorithm vra = vraBuilder.build();
+        VehicleRoute route2 = VehicleRoute.Builder.newInstance(vehicle).setJobActivityFactory(vrp.getJobActivityFactory())
-        vra.setMaxIterations(100);
+                .addService(s3).addPickup(shipment2).addDelivery(shipment2).addService(s4).build();
-        solution = Solutions.bestOf(vra.searchSolutions());
 
+        solution = new VehicleRoutingProblemSolution(Arrays.asList(route1,route2),42);
     }
 
     @Test
@@ -244,21 +232,6 @@ public class SolutionAnalyserTest {
         Assert.assertEquals(5, analyser.getLoadRightAfterActivity(route.getEnd(), route).get(0));
     }
 
-    @Test
-    public void whatShouldHappenWithAllActStatistics_IfSpecifiedActIsNotInVehicleRoute(){
-        /*
-        there might be the need to add .containsActivity(act) to VehicleRoute
-         */
-        Assert.assertTrue(false);
-    }
-
-    @Test
-    public void whatShouldHappenWithAllActStatistics_IfSpecifiedActIsNull(){
-        Assert.assertTrue(false);
-    }
-
-
-
     @Test
     public void loadBeforeActivity_ofStartActOfRoute1ShouldWork(){
         SolutionAnalyser analyser = new SolutionAnalyser(vrp,solution, new SolutionAnalyser.DistanceCalculator() {
@@ -734,11 +707,6 @@ public class SolutionAnalyserTest {
         Assert.assertEquals(42.*2., analyser.getVariableTransportCostsAtActivity(route.getEnd(), route), 0.01);
     }
 
-    @Test
-    public void whatShouldHappenIf_Route_or_Activity_isEmpty_or_notPartOfRoute(){
-        assertFalse(true);
-    }
-
     @Test
     public void capacityViolationAtBeginning_shouldWork(){
         SolutionAnalyser analyser = new SolutionAnalyser(vrp,solution, new SolutionAnalyser.DistanceCalculator() {
@@ -1265,8 +1233,460 @@ public class SolutionAnalyserTest {
     }
 
     @Test
-    public void testRealViolation(){
+    public void backhaulViolation_shouldWorkWhenViolated(){
-        assertFalse(true);
+        buildAnotherScenarioWithOnlyOneVehicleAndWithoutAnyConstraintsBefore();
+        SolutionPrinter.print(vrp,solution, SolutionPrinter.Print.VERBOSE);
+
+        SolutionAnalyser analyser = new SolutionAnalyser(vrp,solution, new SolutionAnalyser.DistanceCalculator() {
+            @Override
+            public double getDistance(String fromLocationId, String toLocationId) {
+                return vrp.getTransportCosts().getTransportCost(fromLocationId,toLocationId,0.,null,null);
+            }
+        });
+        VehicleRoute route = solution.getRoutes().iterator().next();
+        Boolean violation = analyser.backhaulConstraintIsViolated(route);
+        assertTrue(violation);
+    }
+
+    @Test
+    public void backhaulViolationAtStart_shouldWork(){
+        buildAnotherScenarioWithOnlyOneVehicleAndWithoutAnyConstraintsBefore();
+        SolutionPrinter.print(vrp,solution, SolutionPrinter.Print.VERBOSE);
+
+        SolutionAnalyser analyser = new SolutionAnalyser(vrp,solution, new SolutionAnalyser.DistanceCalculator() {
+            @Override
+            public double getDistance(String fromLocationId, String toLocationId) {
+                return vrp.getTransportCosts().getTransportCost(fromLocationId,toLocationId,0.,null,null);
+            }
+        });
+        VehicleRoute route = solution.getRoutes().iterator().next();
+        Boolean violation = analyser.backhaulConstraintIsViolatedAtActivity(route.getStart(), route);
+        assertFalse(violation);
+    }
+
+    @Test
+    public void backhaulViolationAtAct1_shouldWork(){
+        buildAnotherScenarioWithOnlyOneVehicleAndWithoutAnyConstraintsBefore();
+
+        SolutionPrinter.print(vrp,solution, SolutionPrinter.Print.VERBOSE);
+
+        SolutionAnalyser analyser = new SolutionAnalyser(vrp,solution, new SolutionAnalyser.DistanceCalculator() {
+            @Override
+            public double getDistance(String fromLocationId, String toLocationId) {
+                return vrp.getTransportCosts().getTransportCost(fromLocationId,toLocationId,0.,null,null);
+            }
+        });
+        VehicleRoute route = solution.getRoutes().iterator().next();
+        Boolean violation = analyser.backhaulConstraintIsViolatedAtActivity(route.getActivities().get(0),route);
+        assertFalse(violation);
+    }
+
+    @Test
+    public void backhaulViolationAtAct2_shouldWork(){
+        buildAnotherScenarioWithOnlyOneVehicleAndWithoutAnyConstraintsBefore();
+        SolutionPrinter.print(vrp,solution, SolutionPrinter.Print.VERBOSE);
+
+        SolutionAnalyser analyser = new SolutionAnalyser(vrp,solution, new SolutionAnalyser.DistanceCalculator() {
+            @Override
+            public double getDistance(String fromLocationId, String toLocationId) {
+                return vrp.getTransportCosts().getTransportCost(fromLocationId,toLocationId,0.,null,null);
+            }
+        });
+        VehicleRoute route = solution.getRoutes().iterator().next();
+        Boolean violation = analyser.backhaulConstraintIsViolatedAtActivity(route.getActivities().get(1),route);
+        assertFalse(violation);
+    }
+
+    @Test
+    public void backhaulViolationAtAct3_shouldWork(){
+        buildAnotherScenarioWithOnlyOneVehicleAndWithoutAnyConstraintsBefore();
+        SolutionPrinter.print(vrp,solution, SolutionPrinter.Print.VERBOSE);
+
+        SolutionAnalyser analyser = new SolutionAnalyser(vrp,solution, new SolutionAnalyser.DistanceCalculator() {
+            @Override
+            public double getDistance(String fromLocationId, String toLocationId) {
+                return vrp.getTransportCosts().getTransportCost(fromLocationId,toLocationId,0.,null,null);
+            }
+        });
+        VehicleRoute route = solution.getRoutes().iterator().next();
+        Boolean violation = analyser.backhaulConstraintIsViolatedAtActivity(route.getActivities().get(2),route);
+        assertFalse(violation);
+    }
+
+    @Test
+    public void backhaulViolationAtAct4_shouldWork(){
+        buildAnotherScenarioWithOnlyOneVehicleAndWithoutAnyConstraintsBefore();
+        SolutionPrinter.print(vrp,solution, SolutionPrinter.Print.VERBOSE);
+
+        SolutionAnalyser analyser = new SolutionAnalyser(vrp,solution, new SolutionAnalyser.DistanceCalculator() {
+            @Override
+            public double getDistance(String fromLocationId, String toLocationId) {
+                return vrp.getTransportCosts().getTransportCost(fromLocationId,toLocationId,0.,null,null);
+            }
+        });
+        VehicleRoute route = solution.getRoutes().iterator().next();
+        Boolean violation = analyser.backhaulConstraintIsViolatedAtActivity(route.getActivities().get(3),route);
+        assertTrue(violation);
+    }
+
+    @Test
+    public void backhaulViolationAtAct5_shouldWork(){
+        buildAnotherScenarioWithOnlyOneVehicleAndWithoutAnyConstraintsBefore();
+        SolutionPrinter.print(vrp,solution, SolutionPrinter.Print.VERBOSE);
+
+        SolutionAnalyser analyser = new SolutionAnalyser(vrp,solution, new SolutionAnalyser.DistanceCalculator() {
+            @Override
+            public double getDistance(String fromLocationId, String toLocationId) {
+                return vrp.getTransportCosts().getTransportCost(fromLocationId,toLocationId,0.,null,null);
+            }
+        });
+        VehicleRoute route = solution.getRoutes().iterator().next();
+        Boolean violation = analyser.backhaulConstraintIsViolatedAtActivity(route.getActivities().get(4),route);
+        assertTrue(violation);
+    }
+
+    @Test
+    public void backhaulViolationAtAct6_shouldWork(){
+        buildAnotherScenarioWithOnlyOneVehicleAndWithoutAnyConstraintsBefore();
+        SolutionPrinter.print(vrp,solution, SolutionPrinter.Print.VERBOSE);
+
+        SolutionAnalyser analyser = new SolutionAnalyser(vrp,solution, new SolutionAnalyser.DistanceCalculator() {
+            @Override
+            public double getDistance(String fromLocationId, String toLocationId) {
+                return vrp.getTransportCosts().getTransportCost(fromLocationId,toLocationId,0.,null,null);
+            }
+        });
+        VehicleRoute route = solution.getRoutes().iterator().next();
+        Boolean violation = analyser.backhaulConstraintIsViolatedAtActivity(route.getActivities().get(5),route);
+        assertFalse(violation);
+    }
+
+    @Test
+    public void backhaulViolationAtAct7_shouldWork(){
+        buildAnotherScenarioWithOnlyOneVehicleAndWithoutAnyConstraintsBefore();
+        SolutionPrinter.print(vrp,solution, SolutionPrinter.Print.VERBOSE);
+
+        SolutionAnalyser analyser = new SolutionAnalyser(vrp,solution, new SolutionAnalyser.DistanceCalculator() {
+            @Override
+            public double getDistance(String fromLocationId, String toLocationId) {
+                return vrp.getTransportCosts().getTransportCost(fromLocationId,toLocationId,0.,null,null);
+            }
+        });
+        VehicleRoute route = solution.getRoutes().iterator().next();
+        Boolean violation = analyser.backhaulConstraintIsViolatedAtActivity(route.getActivities().get(6),route);
+        assertFalse(violation);
+    }
+
+    @Test
+    public void backhaulViolationAtAct8_shouldWork(){
+        buildAnotherScenarioWithOnlyOneVehicleAndWithoutAnyConstraintsBefore();
+        SolutionPrinter.print(vrp,solution, SolutionPrinter.Print.VERBOSE);
+
+        SolutionAnalyser analyser = new SolutionAnalyser(vrp,solution, new SolutionAnalyser.DistanceCalculator() {
+            @Override
+            public double getDistance(String fromLocationId, String toLocationId) {
+                return vrp.getTransportCosts().getTransportCost(fromLocationId,toLocationId,0.,null,null);
+            }
+        });
+        VehicleRoute route = solution.getRoutes().iterator().next();
+        Boolean violation = analyser.backhaulConstraintIsViolatedAtActivity(route.getActivities().get(7),route);
+        assertFalse(violation);
+    }
+
+    @Test
+    public void backhaulViolationAtEnd_shouldWork(){
+        buildAnotherScenarioWithOnlyOneVehicleAndWithoutAnyConstraintsBefore();
+        SolutionPrinter.print(vrp,solution, SolutionPrinter.Print.VERBOSE);
+
+        SolutionAnalyser analyser = new SolutionAnalyser(vrp,solution, new SolutionAnalyser.DistanceCalculator() {
+            @Override
+            public double getDistance(String fromLocationId, String toLocationId) {
+                return vrp.getTransportCosts().getTransportCost(fromLocationId,toLocationId,0.,null,null);
+            }
+        });
+        VehicleRoute route = solution.getRoutes().iterator().next();
+        Boolean violation = analyser.backhaulConstraintIsViolatedAtActivity(route.getEnd(),route);
+        assertFalse(violation);
+    }
+
+    @Test
+    public void shipmentViolationAtStart_shouldWork(){
+        buildAnotherScenarioWithOnlyOneVehicleAndWithoutAnyConstraintsBefore();
+        SolutionPrinter.print(vrp,solution, SolutionPrinter.Print.VERBOSE);
+
+        SolutionAnalyser analyser = new SolutionAnalyser(vrp,solution, new SolutionAnalyser.DistanceCalculator() {
+            @Override
+            public double getDistance(String fromLocationId, String toLocationId) {
+                return vrp.getTransportCosts().getTransportCost(fromLocationId,toLocationId,0.,null,null);
+            }
+        });
+        VehicleRoute route = solution.getRoutes().iterator().next();
+        Boolean violation = analyser.shipmentConstraintIsViolatedAtActivity(route.getStart(), route);
+        assertFalse(violation);
+    }
+
+    @Test
+    public void shipmentViolationAtAct1_shouldWork(){
+        buildAnotherScenarioWithOnlyOneVehicleAndWithoutAnyConstraintsBefore();
+        SolutionPrinter.print(vrp,solution, SolutionPrinter.Print.VERBOSE);
+
+        SolutionAnalyser analyser = new SolutionAnalyser(vrp,solution, new SolutionAnalyser.DistanceCalculator() {
+            @Override
+            public double getDistance(String fromLocationId, String toLocationId) {
+                return vrp.getTransportCosts().getTransportCost(fromLocationId,toLocationId,0.,null,null);
+            }
+        });
+        VehicleRoute route = solution.getRoutes().iterator().next();
+        Boolean violation = analyser.backhaulConstraintIsViolatedAtActivity(route.getActivities().get(0),route);
+        assertFalse(violation);
+    }
+
+    @Test
+    public void shipmentViolationAtAct2_shouldWork(){
+        buildAnotherScenarioWithOnlyOneVehicleAndWithoutAnyConstraintsBefore();
+        SolutionPrinter.print(vrp,solution, SolutionPrinter.Print.VERBOSE);
+
+        SolutionAnalyser analyser = new SolutionAnalyser(vrp,solution, new SolutionAnalyser.DistanceCalculator() {
+            @Override
+            public double getDistance(String fromLocationId, String toLocationId) {
+                return vrp.getTransportCosts().getTransportCost(fromLocationId,toLocationId,0.,null,null);
+            }
+        });
+        VehicleRoute route = solution.getRoutes().iterator().next();
+        Boolean violation = analyser.backhaulConstraintIsViolatedAtActivity(route.getActivities().get(1),route);
+        assertFalse(violation);
+    }
+
+    @Test
+    public void shipmentViolationAtAct3_shouldWork(){
+        buildAnotherScenarioWithOnlyOneVehicleAndWithoutAnyConstraintsBefore();
+        SolutionPrinter.print(vrp,solution, SolutionPrinter.Print.VERBOSE);
+
+        SolutionAnalyser analyser = new SolutionAnalyser(vrp,solution, new SolutionAnalyser.DistanceCalculator() {
+            @Override
+            public double getDistance(String fromLocationId, String toLocationId) {
+                return vrp.getTransportCosts().getTransportCost(fromLocationId,toLocationId,0.,null,null);
+            }
+        });
+        VehicleRoute route = solution.getRoutes().iterator().next();
+        Boolean violation = analyser.backhaulConstraintIsViolatedAtActivity(route.getActivities().get(2),route);
+        assertFalse(violation);
+    }
+
+    @Test
+    public void shipmentViolationAtAct4_shouldWork(){
+        buildAnotherScenarioWithOnlyOneVehicleAndWithoutAnyConstraintsBefore();
+        SolutionPrinter.print(vrp,solution, SolutionPrinter.Print.VERBOSE);
+
+        SolutionAnalyser analyser = new SolutionAnalyser(vrp,solution, new SolutionAnalyser.DistanceCalculator() {
+            @Override
+            public double getDistance(String fromLocationId, String toLocationId) {
+                return vrp.getTransportCosts().getTransportCost(fromLocationId,toLocationId,0.,null,null);
+            }
+        });
+        VehicleRoute route = solution.getRoutes().iterator().next();
+        Boolean violation = analyser.backhaulConstraintIsViolatedAtActivity(route.getActivities().get(3),route);
+        assertTrue(violation);
+    }
+
+    @Test
+    public void shipmentViolationAtAct5_shouldWork(){
+        buildAnotherScenarioWithOnlyOneVehicleAndWithoutAnyConstraintsBefore();
+        SolutionPrinter.print(vrp,solution, SolutionPrinter.Print.VERBOSE);
+
+        SolutionAnalyser analyser = new SolutionAnalyser(vrp,solution, new SolutionAnalyser.DistanceCalculator() {
+            @Override
+            public double getDistance(String fromLocationId, String toLocationId) {
+                return vrp.getTransportCosts().getTransportCost(fromLocationId,toLocationId,0.,null,null);
+            }
+        });
+        VehicleRoute route = solution.getRoutes().iterator().next();
+        Boolean violation = analyser.backhaulConstraintIsViolatedAtActivity(route.getActivities().get(4),route);
+        assertTrue(violation);
+    }
+
+    @Test
+    public void shipmentViolationAtAct6_shouldWork(){
+        buildAnotherScenarioWithOnlyOneVehicleAndWithoutAnyConstraintsBefore();
+        SolutionPrinter.print(vrp,solution, SolutionPrinter.Print.VERBOSE);
+
+        SolutionAnalyser analyser = new SolutionAnalyser(vrp,solution, new SolutionAnalyser.DistanceCalculator() {
+            @Override
+            public double getDistance(String fromLocationId, String toLocationId) {
+                return vrp.getTransportCosts().getTransportCost(fromLocationId,toLocationId,0.,null,null);
+            }
+        });
+        VehicleRoute route = solution.getRoutes().iterator().next();
+        Boolean violation = analyser.backhaulConstraintIsViolatedAtActivity(route.getActivities().get(5),route);
+        assertFalse(violation);
+    }
+
+    @Test
+    public void shipmentViolationAtAct7_shouldWork(){
+        buildAnotherScenarioWithOnlyOneVehicleAndWithoutAnyConstraintsBefore();
+        SolutionPrinter.print(vrp,solution, SolutionPrinter.Print.VERBOSE);
+
+        SolutionAnalyser analyser = new SolutionAnalyser(vrp,solution, new SolutionAnalyser.DistanceCalculator() {
+            @Override
+            public double getDistance(String fromLocationId, String toLocationId) {
+                return vrp.getTransportCosts().getTransportCost(fromLocationId,toLocationId,0.,null,null);
+            }
+        });
+        VehicleRoute route = solution.getRoutes().iterator().next();
+        Boolean violation = analyser.backhaulConstraintIsViolatedAtActivity(route.getActivities().get(6),route);
+        assertFalse(violation);
+    }
+
+    @Test
+    public void shipmentViolationAtAct8_shouldWork(){
+        buildAnotherScenarioWithOnlyOneVehicleAndWithoutAnyConstraintsBefore();
+        SolutionPrinter.print(vrp,solution, SolutionPrinter.Print.VERBOSE);
+
+        SolutionAnalyser analyser = new SolutionAnalyser(vrp,solution, new SolutionAnalyser.DistanceCalculator() {
+            @Override
+            public double getDistance(String fromLocationId, String toLocationId) {
+                return vrp.getTransportCosts().getTransportCost(fromLocationId,toLocationId,0.,null,null);
+            }
+        });
+        VehicleRoute route = solution.getRoutes().iterator().next();
+        Boolean violation = analyser.backhaulConstraintIsViolatedAtActivity(route.getActivities().get(7),route);
+        assertFalse(violation);
+    }
+
+    @Test
+    public void shipmentViolationAtEnd_shouldWork(){
+        buildAnotherScenarioWithOnlyOneVehicleAndWithoutAnyConstraintsBefore();
+        SolutionPrinter.print(vrp,solution, SolutionPrinter.Print.VERBOSE);
+
+        SolutionAnalyser analyser = new SolutionAnalyser(vrp,solution, new SolutionAnalyser.DistanceCalculator() {
+            @Override
+            public double getDistance(String fromLocationId, String toLocationId) {
+                return vrp.getTransportCosts().getTransportCost(fromLocationId,toLocationId,0.,null,null);
+            }
+        });
+        VehicleRoute route = solution.getRoutes().iterator().next();
+        Boolean violation = analyser.backhaulConstraintIsViolatedAtActivity(route.getEnd(),route);
+        assertFalse(violation);
+    }
+
+    @Test
+    public void shipmentViolation_shouldWork(){
+        buildAnotherScenarioWithOnlyOneVehicleAndWithoutAnyConstraintsBefore();
+        SolutionPrinter.print(vrp,solution, SolutionPrinter.Print.VERBOSE);
+
+        SolutionAnalyser analyser = new SolutionAnalyser(vrp,solution, new SolutionAnalyser.DistanceCalculator() {
+            @Override
+            public double getDistance(String fromLocationId, String toLocationId) {
+                return vrp.getTransportCosts().getTransportCost(fromLocationId,toLocationId,0.,null,null);
+            }
+        });
+        VehicleRoute route = solution.getRoutes().iterator().next();
+        Boolean violation = analyser.shipmentConstraintIsViolated(route);
+        assertFalse(violation);
+    }
+
+    @Test
+    public void shipmentViolation_shouldWorkWhenViolated(){
+        buildAnotherScenarioWithOnlyOneVehicleAndWithoutAnyConstraintsBefore();
+        VehicleRoute route = solution.getRoutes().iterator().next();
+        SolutionPrinter.print(vrp,solution, SolutionPrinter.Print.VERBOSE);
+        TourActivity deliverShipment = route.getActivities().get(2);
+        route.getTourActivities().removeActivity(deliverShipment);
+//        SolutionPrinter.print(vrp,solution, SolutionPrinter.Print.VERBOSE);
+
+        SolutionAnalyser analyser = new SolutionAnalyser(vrp,solution, new SolutionAnalyser.DistanceCalculator() {
+            @Override
+            public double getDistance(String fromLocationId, String toLocationId) {
+                return vrp.getTransportCosts().getTransportCost(fromLocationId,toLocationId,0.,null,null);
+            }
+        });
+
+        Boolean violation = analyser.shipmentConstraintIsViolated(route);
+        assertTrue(violation);
+    }
+
+    @Test
+    public void shipmentViolationAtActivity_shouldWorkWhenRemovingDelivery(){
+        buildAnotherScenarioWithOnlyOneVehicleAndWithoutAnyConstraintsBefore();
+        VehicleRoute route = solution.getRoutes().iterator().next();
+        SolutionPrinter.print(vrp,solution, SolutionPrinter.Print.VERBOSE);
+        TourActivity deliverShipment = route.getActivities().get(2);
+        route.getTourActivities().removeActivity(deliverShipment);
+//        assertFalse(route.getTourActivities().hasActivity(pickupShipment));
+        SolutionPrinter.print(vrp,solution, SolutionPrinter.Print.VERBOSE);
+
+        SolutionAnalyser analyser = new SolutionAnalyser(vrp,solution, new SolutionAnalyser.DistanceCalculator() {
+            @Override
+            public double getDistance(String fromLocationId, String toLocationId) {
+                return vrp.getTransportCosts().getTransportCost(fromLocationId,toLocationId,0.,null,null);
+            }
+        });
+
+        Boolean violation = analyser.shipmentConstraintIsViolatedAtActivity(route.getActivities().get(1), route);
+        assertTrue(violation);
+    }
+
+    @Test
+    public void shipmentViolation_shouldWorkWhenRemovingDelivery(){
+        buildAnotherScenarioWithOnlyOneVehicleAndWithoutAnyConstraintsBefore();
+        VehicleRoute route = solution.getRoutes().iterator().next();
+        SolutionPrinter.print(vrp,solution, SolutionPrinter.Print.VERBOSE);
+        TourActivity deliverShipment = route.getActivities().get(2);
+        route.getTourActivities().removeActivity(deliverShipment);
+        assertFalse(route.getTourActivities().hasActivity(deliverShipment));
+        SolutionPrinter.print(vrp,solution, SolutionPrinter.Print.VERBOSE);
+
+        SolutionAnalyser analyser = new SolutionAnalyser(vrp,solution, new SolutionAnalyser.DistanceCalculator() {
+            @Override
+            public double getDistance(String fromLocationId, String toLocationId) {
+                return vrp.getTransportCosts().getTransportCost(fromLocationId,toLocationId,0.,null,null);
+            }
+        });
+
+        Boolean violation = analyser.shipmentConstraintIsViolated(route);
+        assertTrue(violation);
+    }
+
+    @Test
+    public void shipmentViolationAtActivity_shouldWorkWhenRemovingPickup(){
+        buildAnotherScenarioWithOnlyOneVehicleAndWithoutAnyConstraintsBefore();
+        VehicleRoute route = solution.getRoutes().iterator().next();
+        SolutionPrinter.print(vrp,solution, SolutionPrinter.Print.VERBOSE);
+        TourActivity pickupShipment = route.getActivities().get(1);
+        route.getTourActivities().removeActivity(pickupShipment);
+        assertFalse(route.getTourActivities().hasActivity(pickupShipment));
+        SolutionPrinter.print(vrp,solution, SolutionPrinter.Print.VERBOSE);
+
+        SolutionAnalyser analyser = new SolutionAnalyser(vrp,solution, new SolutionAnalyser.DistanceCalculator() {
+            @Override
+            public double getDistance(String fromLocationId, String toLocationId) {
+                return vrp.getTransportCosts().getTransportCost(fromLocationId,toLocationId,0.,null,null);
+            }
+        });
+
+        Boolean violation = analyser.shipmentConstraintIsViolatedAtActivity(route.getActivities().get(1),route);
+        assertTrue(violation);
+    }
+
+    @Test
+    public void shipmentViolationOnRoute_shouldWorkWhenRemovingPickup(){
+        buildAnotherScenarioWithOnlyOneVehicleAndWithoutAnyConstraintsBefore();
+        VehicleRoute route = solution.getRoutes().iterator().next();
+        SolutionPrinter.print(vrp,solution, SolutionPrinter.Print.VERBOSE);
+        TourActivity pickupShipment = route.getActivities().get(1);
+        route.getTourActivities().removeActivity(pickupShipment);
+        assertFalse(route.getTourActivities().hasActivity(pickupShipment));
+        SolutionPrinter.print(vrp,solution, SolutionPrinter.Print.VERBOSE);
+
+        SolutionAnalyser analyser = new SolutionAnalyser(vrp,solution, new SolutionAnalyser.DistanceCalculator() {
+            @Override
+            public double getDistance(String fromLocationId, String toLocationId) {
+                return vrp.getTransportCosts().getTransportCost(fromLocationId,toLocationId,0.,null,null);
+            }
+        });
+
+        Boolean violation = analyser.shipmentConstraintIsViolated(route);
+        assertTrue(violation);
     }
 
 
@@ -1316,68 +1736,32 @@ public class SolutionAnalyserTest {
         vrpBuilder.setRoutingCost(new ManhattanCosts(vrpBuilder.getLocations()));
         vrp = vrpBuilder.build();
 
-        VehicleRoutingAlgorithmBuilder vraBuilder = new VehicleRoutingAlgorithmBuilder(vrp,"src/test/resources/algorithmConfig.xml");
+        VehicleRoute route = VehicleRoute.Builder.newInstance(vehicle).setJobActivityFactory(vrp.getJobActivityFactory())
-        vraBuilder.addDefaultCostCalculators();
+                .addPickup(s3)
+                .addPickup(shipment2).addDelivery(shipment2)
+                .addDelivery(s4)
+                .addDelivery(s2)
+                .addPickup(shipment1).addDelivery(shipment1)
+                .addPickup(s1)
+                .build();
 
-        //adds updater
+        solution = new VehicleRoutingProblemSolution(Arrays.asList(route),300);
-        stateManager = new StateManager(vrp);
+//        VehicleRoutingAlgorithmBuilder vraBuilder = new VehicleRoutingAlgorithmBuilder(vrp,"src/test/resources/algorithmConfig.xml");
-        stateManager.updateLoadStates();
+//        vraBuilder.addDefaultCostCalculators();
-        stateManager.updateTimeWindowStates();
+//
-
+//        //adds updater
-        //but no constraints to simulate violation
+//        StateManager stateManager = new StateManager(vrp);
-        ConstraintManager constraintManager = new ConstraintManager(vrp,stateManager);
+//        stateManager.updateLoadStates();
-        vraBuilder.setStateAndConstraintManager(stateManager,constraintManager);
+//        stateManager.updateTimeWindowStates();
-
+//
-        VehicleRoutingAlgorithm vra = vraBuilder.build();
+//        //but no constraints to simulate violation
-        vra.setMaxIterations(100);
+//        ConstraintManager constraintManager = new ConstraintManager(vrp,stateManager);
-        solution = Solutions.bestOf(vra.searchSolutions());
+//        vraBuilder.setStateAndConstraintManager(stateManager,constraintManager);
+//
+//        VehicleRoutingAlgorithm vra = vraBuilder.build();
+//        vra.setMaxIterations(100);
+//        solution = Solutions.bestOf(vra.searchSolutions());
 
     }
-//
-//    public void simulateTW_and_LoadConstraint(){
-//        constraintManager.addLoadConstraint();
-//        constraintManager.addTimeWindowConstraint();
-//    }
-
-//    @Test
-//    public void violatedConstraint_shouldReturnTWandCapConstraints(){
-//        buildAnotherScenarioWithOnlyOneVehicleAndWithoutAnyConstraintsBefore();
-//
-//        SolutionPrinter.print(vrp,solution, SolutionPrinter.Print.VERBOSE);
-//
-//        simulateTW_and_LoadConstraint();
-//
-//        SolutionAnalyser analyser = new SolutionAnalyser(vrp,solution, new SolutionAnalyser.DistanceCalculator() {
-//            @Override
-//            public double getDistance(String fromLocationId, String toLocationId) {
-//                return vrp.getTransportCosts().getTransportCost(fromLocationId,toLocationId,0.,null,null);
-//            }
-//        });
-//        VehicleRoute route = solution.getRoutes().iterator().next();
-//        List<HardRouteConstraint> violatedConstraints = analyser.getViolatedHardConstraints(route).getHardRouteConstraints();
-////        Assert.assertEquals(2,violatedConstraints.size());
-//        for(HardRouteConstraint c : violatedConstraints) System.out.println("violated: " + c.getClass().toString());
-//    }
-//
-//    @Test
-//    public void violatedActivityConstraint_shouldWorkForAct1(){
-//        buildAnotherScenarioWithOnlyOneVehicleAndWithoutAnyConstraintsBefore();
-//
-//        SolutionPrinter.print(vrp,solution, SolutionPrinter.Print.VERBOSE);
-//
-//        simulateTW_and_LoadConstraint();
-//
-//        SolutionAnalyser analyser = new SolutionAnalyser(vrp,solution, new SolutionAnalyser.DistanceCalculator() {
-//            @Override
-//            public double getDistance(String fromLocationId, String toLocationId) {
-//                return vrp.getTransportCosts().getTransportCost(fromLocationId,toLocationId,0.,null,null);
-//            }
-//        });
-//
-//        VehicleRoute route = solution.getRoutes().iterator().next();
-//        List<HardActivityConstraint> violatedConstraints = analyser.getViolatedHardConstraintsAtActivity(route.getActivities().get(0),route).getHardActivityConstraints();
-////        Assert.assertEquals(2,violatedConstraints.size());
-//        for(HardActivityConstraint c : violatedConstraints) System.out.println("violated: " + c.getClass().toString());
-//    }
 
 }