merge jsprit-io

jsprit-io/.gitignore

@@ -0,0 +1,18 @@
+/bin
+/target
+/output
+.DS_Store
+
+# IntelliJ
+*.ipr
+*.iws
+*.iml
+.idea
+
+# Eclipse
+.project
+.classpath
+.settings
+
+
+

jsprit-io/pom.xml

@@ -0,0 +1,40 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <parent>
+        <artifactId>jsprit</artifactId>
+        <groupId>jsprit</groupId>
+        <version>1.6.3-SNAPSHOT</version>
+    </parent>
+    <modelVersion>4.0.0</modelVersion>
+
+    <artifactId>jsprit-io</artifactId>
+
+    <dependencies>
+        <dependency>
+            <groupId>${project.groupId}</groupId>
+            <artifactId>jsprit-core</artifactId>
+            <version>${project.version}</version>
+            <type>jar</type>
+            <scope>provided</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>commons-configuration</groupId>
+            <artifactId>commons-configuration</artifactId>
+            <version>1.9</version>
+            <type>jar</type>
+            <scope>compile</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>xerces</groupId>
+            <artifactId>xercesImpl</artifactId>
+            <version>2.11.0</version>
+            <scope>compile</scope>
+        </dependency>
+
+    </dependencies>
+
+</project>

jsprit-io/src/main/java/com/graphhopper/jsprit/io/algorithm/AlgorithmConfig.java

@@ -0,0 +1,33 @@
+/*******************************************************************************
+ * 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 com.graphhopper.jsprit.io.algorithm;
+
+import org.apache.commons.configuration.XMLConfiguration;
+
+public class AlgorithmConfig {
+
+    private XMLConfiguration xmlConfig;
+
+    public AlgorithmConfig() {
+        xmlConfig = new XMLConfiguration();
+
+    }
+
+    public XMLConfiguration getXMLConfiguration() {
+        return xmlConfig;
+    }
+}

jsprit-io/src/main/java/com/graphhopper/jsprit/io/algorithm/AlgorithmConfigXmlReader.java

@@ -0,0 +1,91 @@
+/*******************************************************************************
+ * 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 com.graphhopper.jsprit.io.algorithm;
+
+import com.graphhopper.jsprit.core.util.Resource;
+import org.apache.commons.configuration.ConfigurationException;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.xml.sax.EntityResolver;
+import org.xml.sax.InputSource;
+import org.xml.sax.SAXException;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.URL;
+
+
+public class AlgorithmConfigXmlReader {
+
+    private static Logger log = LoggerFactory.getLogger(AlgorithmConfigXmlReader.class.getName());
+
+    private AlgorithmConfig algorithmConfig;
+
+    private boolean schemaValidation = true;
+
+    /**
+     * @param schemaValidation the schemaValidation to set
+     */
+    public AlgorithmConfigXmlReader setSchemaValidation(boolean schemaValidation) {
+        this.schemaValidation = schemaValidation;
+        return this;
+    }
+
+    public AlgorithmConfigXmlReader(AlgorithmConfig algorithmConfig) {
+        this.algorithmConfig = algorithmConfig;
+    }
+
+    public void read(URL url) {
+        log.debug("read algorithm: " + url);
+        algorithmConfig.getXMLConfiguration().setURL(url);
+        algorithmConfig.getXMLConfiguration().setAttributeSplittingDisabled(true);
+        algorithmConfig.getXMLConfiguration().setDelimiterParsingDisabled(true);
+
+        if (schemaValidation) {
+            final InputStream resource = Resource.getAsInputStream("algorithm_schema.xsd");
+            if (resource != null) {
+                EntityResolver resolver = new EntityResolver() {
+
+                    @Override
+                    public InputSource resolveEntity(String publicId, String systemId) throws SAXException, IOException {
+                        {
+                            InputSource is = new InputSource(resource);
+                            return is;
+                        }
+                    }
+                };
+                algorithmConfig.getXMLConfiguration().setEntityResolver(resolver);
+                algorithmConfig.getXMLConfiguration().setSchemaValidation(true);
+            } else {
+                log.warn("cannot find schema-xsd file (algorithm_xml_schema.xsd). try to read xml without xml-file-validation.");
+            }
+        }
+        try {
+            algorithmConfig.getXMLConfiguration().load();
+        } catch (ConfigurationException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+
+    public void read(String filename) {
+        log.debug("read algorithm-config from file " + filename);
+        URL url = Resource.getAsURL(filename);
+        read(url);
+    }
+
+}

jsprit-io/src/main/java/com/graphhopper/jsprit/io/algorithm/InsertionFactory.java

@@ -0,0 +1,115 @@
+/*******************************************************************************
+ * 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/>.
+ ******************************************************************************/
+package com.graphhopper.jsprit.io.algorithm;
+
+import com.graphhopper.jsprit.core.algorithm.listener.VehicleRoutingAlgorithmListeners;
+import com.graphhopper.jsprit.core.algorithm.recreate.InsertionBuilder;
+import com.graphhopper.jsprit.core.algorithm.recreate.InsertionStrategy;
+import com.graphhopper.jsprit.core.algorithm.state.StateManager;
+import com.graphhopper.jsprit.core.problem.VehicleRoutingProblem;
+import com.graphhopper.jsprit.core.problem.constraint.ConstraintManager;
+import com.graphhopper.jsprit.core.problem.vehicle.VehicleFleetManager;
+import org.apache.commons.configuration.HierarchicalConfiguration;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.List;
+import java.util.concurrent.ExecutorService;
+
+
+class InsertionFactory {
+
+    private static Logger log = LoggerFactory.getLogger(InsertionFactory.class.getName());
+
+    @SuppressWarnings("deprecation")
+    public static InsertionStrategy createInsertion(VehicleRoutingProblem vrp, HierarchicalConfiguration config,
+                                                    VehicleFleetManager vehicleFleetManager, StateManager stateManager, List<VehicleRoutingAlgorithmListeners.PrioritizedVRAListener> algorithmListeners, ExecutorService executorService, int nuOfThreads, ConstraintManager constraintManager, boolean addDefaultCostCalculators) {
+
+        if (config.containsKey("[@name]")) {
+            String insertionName = config.getString("[@name]");
+            if (!insertionName.equals("bestInsertion") && !insertionName.equals("regretInsertion")) {
+                throw new IllegalStateException(insertionName + " is not supported. use either \"bestInsertion\" or \"regretInsertion\"");
+            }
+
+
+            InsertionBuilder iBuilder = new InsertionBuilder(vrp, vehicleFleetManager, stateManager, constraintManager);
+
+            if (executorService != null) {
+                iBuilder.setConcurrentMode(executorService, nuOfThreads);
+            }
+
+            if (config.containsKey("level")) {
+                String level = config.getString("level");
+                if (level.equals("local")) {
+                    iBuilder.setLocalLevel(addDefaultCostCalculators);
+                } else if (level.equals("route")) {
+                    int forwardLooking = 0;
+                    int memory = 1;
+                    String forward = config.getString("level[@forwardLooking]");
+                    String mem = config.getString("level[@memory]");
+                    if (forward != null) forwardLooking = Integer.parseInt(forward);
+                    else
+                        log.warn("parameter route[@forwardLooking] is missing. by default it is 0 which equals to local level");
+                    if (mem != null) memory = Integer.parseInt(mem);
+                    else log.warn("parameter route[@memory] is missing. by default it is 1");
+                    iBuilder.setRouteLevel(forwardLooking, memory, addDefaultCostCalculators);
+                } else
+                    throw new IllegalStateException("level " + level + " is not known. currently it only knows \"local\" or \"route\"");
+            } else iBuilder.setLocalLevel(addDefaultCostCalculators);
+
+            if (config.containsKey("considerFixedCosts") || config.containsKey("considerFixedCost")) {
+                if (addDefaultCostCalculators) {
+                    String val = config.getString("considerFixedCosts");
+                    if (val == null) val = config.getString("considerFixedCost");
+                    if (val.equals("true")) {
+                        double fixedCostWeight = 0.5;
+                        String weight = config.getString("considerFixedCosts[@weight]");
+                        if (weight == null) weight = config.getString("considerFixedCost[@weight]");
+                        if (weight != null) fixedCostWeight = Double.parseDouble(weight);
+                        else
+                            throw new IllegalStateException("fixedCostsParameter 'weight' must be set, e.g. <considerFixedCosts weight=1.0>true</considerFixedCosts>.\n" +
+                                "this has to be changed in algorithm-config-xml-file.");
+                        iBuilder.considerFixedCosts(fixedCostWeight);
+                    } else if (val.equals("false")) {
+
+                    } else
+                        throw new IllegalStateException("considerFixedCosts must either be true or false, i.e. <considerFixedCosts weight=1.0>true</considerFixedCosts> or \n<considerFixedCosts weight=1.0>false</considerFixedCosts>. " +
+                            "if latter, you can also omit the tag. this has to be changed in algorithm-config-xml-file");
+                }
+            }
+            String allowVehicleSwitch = config.getString("allowVehicleSwitch");
+            if (allowVehicleSwitch != null) {
+                iBuilder.setAllowVehicleSwitch(Boolean.parseBoolean(allowVehicleSwitch));
+            }
+
+            if (insertionName.equals("regretInsertion")) {
+                iBuilder.setInsertionStrategy(InsertionBuilder.Strategy.REGRET);
+
+                String fastRegret = config.getString("fastRegret");
+                if (fastRegret != null) {
+                    iBuilder.setFastRegret(Boolean.parseBoolean(fastRegret));
+                }
+            }
+            return iBuilder.build();
+        } else throw new IllegalStateException("cannot create insertionStrategy, since it has no name.");
+    }
+
+
+}
+
+
+

jsprit-io/src/main/java/com/graphhopper/jsprit/io/algorithm/VehicleRoutingAlgorithms.java

@@ -0,0 +1,907 @@
+/*******************************************************************************
+ * 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/>.
+ ******************************************************************************/
+package com.graphhopper.jsprit.io.algorithm;
+
+
+import com.graphhopper.jsprit.core.algorithm.*;
+import com.graphhopper.jsprit.core.algorithm.acceptor.*;
+import com.graphhopper.jsprit.core.algorithm.listener.AlgorithmEndsListener;
+import com.graphhopper.jsprit.core.algorithm.listener.VehicleRoutingAlgorithmListeners.PrioritizedVRAListener;
+import com.graphhopper.jsprit.core.algorithm.listener.VehicleRoutingAlgorithmListeners.Priority;
+import com.graphhopper.jsprit.core.algorithm.module.RuinAndRecreateModule;
+import com.graphhopper.jsprit.core.algorithm.recreate.InsertionStrategy;
+import com.graphhopper.jsprit.core.algorithm.recreate.listener.InsertionListener;
+import com.graphhopper.jsprit.core.algorithm.ruin.RadialRuinStrategyFactory;
+import com.graphhopper.jsprit.core.algorithm.ruin.RandomRuinStrategyFactory;
+import com.graphhopper.jsprit.core.algorithm.ruin.RuinStrategy;
+import com.graphhopper.jsprit.core.algorithm.ruin.distance.AvgServiceAndShipmentDistance;
+import com.graphhopper.jsprit.core.algorithm.ruin.distance.JobDistance;
+import com.graphhopper.jsprit.core.algorithm.selector.SelectBest;
+import com.graphhopper.jsprit.core.algorithm.selector.SelectRandomly;
+import com.graphhopper.jsprit.core.algorithm.selector.SolutionSelector;
+import com.graphhopper.jsprit.core.algorithm.state.*;
+import com.graphhopper.jsprit.core.algorithm.termination.IterationWithoutImprovementTermination;
+import com.graphhopper.jsprit.core.algorithm.termination.PrematureAlgorithmTermination;
+import com.graphhopper.jsprit.core.algorithm.termination.TimeTermination;
+import com.graphhopper.jsprit.core.algorithm.termination.VariationCoefficientTermination;
+import com.graphhopper.jsprit.core.problem.VehicleRoutingProblem;
+import com.graphhopper.jsprit.core.problem.VehicleRoutingProblem.FleetSize;
+import com.graphhopper.jsprit.core.problem.constraint.ConstraintManager;
+import com.graphhopper.jsprit.core.problem.constraint.SwitchNotFeasible;
+import com.graphhopper.jsprit.core.problem.solution.SolutionCostCalculator;
+import com.graphhopper.jsprit.core.problem.solution.VehicleRoutingProblemSolution;
+import com.graphhopper.jsprit.core.problem.solution.route.VehicleRoute;
+import com.graphhopper.jsprit.core.problem.solution.route.activity.End;
+import com.graphhopper.jsprit.core.problem.solution.route.activity.ReverseActivityVisitor;
+import com.graphhopper.jsprit.core.problem.solution.route.activity.TourActivity;
+import com.graphhopper.jsprit.core.problem.vehicle.*;
+import com.graphhopper.jsprit.core.util.ActivityTimeTracker;
+import com.graphhopper.jsprit.io.algorithm.VehicleRoutingAlgorithms.TypedMap.*;
+import org.apache.commons.configuration.HierarchicalConfiguration;
+import org.apache.commons.configuration.XMLConfiguration;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+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 {
+
+    static class TypedMap {
+
+        static interface AbstractKey<K> {
+
+            Class<K> getType();
+        }
+
+        static class AcceptorKey implements AbstractKey<SolutionAcceptor> {
+
+            private ModKey modKey;
+
+            public AcceptorKey(ModKey modKey) {
+                super();
+                this.modKey = modKey;
+            }
+
+
+            @Override
+            public int hashCode() {
+                final int prime = 31;
+                int result = 1;
+                result = prime * result
+                    + ((modKey == null) ? 0 : modKey.hashCode());
+                return result;
+            }
+
+
+            @Override
+            public boolean equals(Object obj) {
+                if (this == obj)
+                    return true;
+                if (obj == null)
+                    return false;
+                if (!(obj instanceof AcceptorKey))
+                    return false;
+                AcceptorKey other = (AcceptorKey) obj;
+                if (modKey == null) {
+                    if (other.modKey != null)
+                        return false;
+                } else if (!modKey.equals(other.modKey))
+                    return false;
+                return true;
+            }
+
+
+            @Override
+            public Class<SolutionAcceptor> getType() {
+                return SolutionAcceptor.class;
+            }
+
+        }
+
+        static class SelectorKey implements AbstractKey<SolutionSelector> {
+
+            private ModKey modKey;
+
+            public SelectorKey(ModKey modKey) {
+                super();
+                this.modKey = modKey;
+            }
+
+            @Override
+            public int hashCode() {
+                final int prime = 31;
+                int result = 1;
+                result = prime * result
+                    + ((modKey == null) ? 0 : modKey.hashCode());
+                return result;
+            }
+
+            @Override
+            public boolean equals(Object obj) {
+                if (this == obj)
+                    return true;
+                if (obj == null)
+                    return false;
+                if (getClass() != obj.getClass())
+                    return false;
+                SelectorKey other = (SelectorKey) obj;
+                if (modKey == null) {
+                    if (other.modKey != null)
+                        return false;
+                } else if (!modKey.equals(other.modKey))
+                    return false;
+                return true;
+            }
+
+
+            @Override
+            public Class<SolutionSelector> getType() {
+                return SolutionSelector.class;
+            }
+
+        }
+
+        static class StrategyModuleKey implements AbstractKey<SearchStrategyModule> {
+
+            private ModKey modKey;
+
+            public StrategyModuleKey(ModKey modKey) {
+                super();
+                this.modKey = modKey;
+            }
+
+            @Override
+            public int hashCode() {
+                final int prime = 31;
+                int result = 1;
+                result = prime * result
+                    + ((modKey == null) ? 0 : modKey.hashCode());
+                return result;
+            }
+
+            @Override
+            public boolean equals(Object obj) {
+                if (this == obj)
+                    return true;
+                if (obj == null)
+                    return false;
+                if (getClass() != obj.getClass())
+                    return false;
+                StrategyModuleKey other = (StrategyModuleKey) obj;
+                if (modKey == null) {
+                    if (other.modKey != null)
+                        return false;
+                } else if (!modKey.equals(other.modKey))
+                    return false;
+                return true;
+            }
+
+
+            @Override
+            public Class<SearchStrategyModule> getType() {
+                return SearchStrategyModule.class;
+            }
+
+        }
+
+        static class RuinStrategyKey implements AbstractKey<RuinStrategy> {
+
+            private ModKey modKey;
+
+            public RuinStrategyKey(ModKey modKey) {
+                super();
+                this.modKey = modKey;
+            }
+
+            @Override
+            public int hashCode() {
+                final int prime = 31;
+                int result = 1;
+                result = prime * result
+                    + ((modKey == null) ? 0 : modKey.hashCode());
+                return result;
+            }
+
+            @Override
+            public boolean equals(Object obj) {
+                if (this == obj)
+                    return true;
+                if (obj == null)
+                    return false;
+                if (getClass() != obj.getClass())
+                    return false;
+                RuinStrategyKey other = (RuinStrategyKey) obj;
+                if (modKey == null) {
+                    if (other.modKey != null)
+                        return false;
+                } else if (!modKey.equals(other.modKey))
+                    return false;
+                return true;
+            }
+
+
+            @Override
+            public Class<RuinStrategy> getType() {
+                return RuinStrategy.class;
+            }
+
+        }
+
+        static class InsertionStrategyKey implements AbstractKey<InsertionStrategy> {
+
+            private ModKey modKey;
+
+            public InsertionStrategyKey(ModKey modKey) {
+                super();
+                this.modKey = modKey;
+            }
+
+            @Override
+            public int hashCode() {
+                final int prime = 31;
+                int result = 1;
+                result = prime * result
+                    + ((modKey == null) ? 0 : modKey.hashCode());
+                return result;
+            }
+
+            @Override
+            public boolean equals(Object obj) {
+                if (this == obj)
+                    return true;
+                if (obj == null)
+                    return false;
+                if (getClass() != obj.getClass())
+                    return false;
+                InsertionStrategyKey other = (InsertionStrategyKey) obj;
+                if (modKey == null) {
+                    if (other.modKey != null)
+                        return false;
+                } else if (!modKey.equals(other.modKey))
+                    return false;
+                return true;
+            }
+
+
+            @Override
+            public Class<InsertionStrategy> getType() {
+                return InsertionStrategy.class;
+            }
+
+        }
+
+        private Map<AbstractKey<?>, Object> map = new HashMap<AbstractKey<?>, Object>();
+
+        public <T> T get(AbstractKey<T> key) {
+            if (map.get(key) == null) return null;
+            return key.getType().cast(map.get(key));
+        }
+
+        public <T> T put(AbstractKey<T> key, T value) {
+            return key.getType().cast(map.put(key, key.getType().cast(value)));
+        }
+
+        public Set<AbstractKey<?>> keySet() {
+            return map.keySet();
+        }
+    }
+
+    static class ModKey {
+        private String name;
+        private String id;
+
+        public ModKey(String name, String id) {
+            super();
+            this.name = name;
+            this.id = id;
+        }
+
+        @Override
+        public int hashCode() {
+            final int prime = 31;
+            int result = 1;
+            result = prime * result + ((id == null) ? 0 : id.hashCode());
+            result = prime * result + ((name == null) ? 0 : name.hashCode());
+            return result;
+        }
+
+        @Override
+        public boolean equals(Object obj) {
+            if (this == obj)
+                return true;
+            if (obj == null)
+                return false;
+            if (getClass() != obj.getClass())
+                return false;
+            ModKey other = (ModKey) obj;
+            if (id == null) {
+                if (other.id != null)
+                    return false;
+            } else if (!id.equals(other.id))
+                return false;
+            if (name == null) {
+                if (other.name != null)
+                    return false;
+            } else if (!name.equals(other.name))
+                return false;
+            return true;
+        }
+
+    }
+
+    private static Logger log = LoggerFactory.getLogger(VehicleRoutingAlgorithms.class.getName());
+
+    private VehicleRoutingAlgorithms() {
+    }
+
+    /**
+     * Creates a {@link com.graphhopper.jsprit.core.algorithm.VehicleRoutingAlgorithm} from a AlgorithConfig based on the input vrp.
+     *
+     * @param vrp             the routing problem
+     * @param algorithmConfig the algorithm config
+     * @return {@link com.graphhopper.jsprit.core.algorithm.VehicleRoutingAlgorithm}
+     */
+    public static VehicleRoutingAlgorithm createAlgorithm(final VehicleRoutingProblem vrp, final AlgorithmConfig algorithmConfig) {
+        return createAlgo(vrp, algorithmConfig.getXMLConfiguration(), 0, null);
+    }
+
+    public static VehicleRoutingAlgorithm createAlgorithm(final VehicleRoutingProblem vrp, int nThreads, final AlgorithmConfig algorithmConfig) {
+        return createAlgo(vrp, algorithmConfig.getXMLConfiguration(), nThreads, null);
+    }
+
+    /**
+     * Read and creates a {@link VehicleRoutingAlgorithm} from an url.
+     *
+     * @param vrp       the routing problem
+     * @param configURL config url
+     * @return {@link com.graphhopper.jsprit.core.algorithm.VehicleRoutingAlgorithm}
+     */
+    public static VehicleRoutingAlgorithm readAndCreateAlgorithm(final VehicleRoutingProblem vrp, final URL configURL) {
+        AlgorithmConfig algorithmConfig = new AlgorithmConfig();
+        AlgorithmConfigXmlReader xmlReader = new AlgorithmConfigXmlReader(algorithmConfig);
+        xmlReader.read(configURL);
+        return createAlgo(vrp, algorithmConfig.getXMLConfiguration(), 0, null);
+    }
+
+    public static VehicleRoutingAlgorithm readAndCreateAlgorithm(final VehicleRoutingProblem vrp, int nThreads, final URL configURL) {
+        AlgorithmConfig algorithmConfig = new AlgorithmConfig();
+        AlgorithmConfigXmlReader xmlReader = new AlgorithmConfigXmlReader(algorithmConfig);
+        xmlReader.read(configURL);
+        return createAlgo(vrp, algorithmConfig.getXMLConfiguration(), nThreads, null);
+    }
+
+    /**
+     * Read and creates {@link com.graphhopper.jsprit.core.problem.VehicleRoutingProblem} from config-file.
+     *
+     * @param vrp            the routing problem
+     * @param configFileName the config filename (and location)
+     * @return {@link com.graphhopper.jsprit.core.algorithm.VehicleRoutingAlgorithm}
+     */
+    public static VehicleRoutingAlgorithm readAndCreateAlgorithm(final VehicleRoutingProblem vrp, final String configFileName) {
+        AlgorithmConfig algorithmConfig = new AlgorithmConfig();
+        AlgorithmConfigXmlReader xmlReader = new AlgorithmConfigXmlReader(algorithmConfig);
+        xmlReader.read(configFileName);
+        return createAlgo(vrp, algorithmConfig.getXMLConfiguration(), 0, null);
+    }
+
+    public static VehicleRoutingAlgorithm readAndCreateAlgorithm(final VehicleRoutingProblem vrp, final String configFileName, StateManager stateManager) {
+        AlgorithmConfig algorithmConfig = new AlgorithmConfig();
+        AlgorithmConfigXmlReader xmlReader = new AlgorithmConfigXmlReader(algorithmConfig);
+        xmlReader.read(configFileName);
+        return createAlgo(vrp, algorithmConfig.getXMLConfiguration(), 0, stateManager);
+    }
+
+    public static VehicleRoutingAlgorithm readAndCreateAlgorithm(final VehicleRoutingProblem vrp, int nThreads, final String configFileName, StateManager stateManager) {
+        AlgorithmConfig algorithmConfig = new AlgorithmConfig();
+        AlgorithmConfigXmlReader xmlReader = new AlgorithmConfigXmlReader(algorithmConfig);
+        xmlReader.read(configFileName);
+        return createAlgo(vrp, algorithmConfig.getXMLConfiguration(), nThreads, stateManager);
+    }
+
+    public static VehicleRoutingAlgorithm readAndCreateAlgorithm(VehicleRoutingProblem vrp, int nThreads, String configFileName) {
+        AlgorithmConfig algorithmConfig = new AlgorithmConfig();
+        AlgorithmConfigXmlReader xmlReader = new AlgorithmConfigXmlReader(algorithmConfig);
+        xmlReader.read(configFileName);
+        return createAlgo(vrp, algorithmConfig.getXMLConfiguration(), nThreads, null);
+    }
+
+    private static class OpenRouteStateVerifier implements StateUpdater, ReverseActivityVisitor {
+
+        private End end;
+
+        private boolean firstAct = true;
+
+        private Vehicle vehicle;
+
+        @Override
+        public void begin(VehicleRoute route) {
+            end = route.getEnd();
+            vehicle = route.getVehicle();
+        }
+
+        @Override
+        public void visit(TourActivity activity) {
+            if (firstAct) {
+                firstAct = false;
+                if (!vehicle.isReturnToDepot()) {
+                    assert activity.getLocation().getId().equals(end.getLocation().getId()) : "route end and last activity are not equal even route is open. this should not be.";
+                }
+            }
+
+        }
+
+        @Override
+        public void finish() {
+            firstAct = true;
+        }
+
+    }
+
+    private static VehicleRoutingAlgorithm createAlgo(final VehicleRoutingProblem vrp, XMLConfiguration config, int nuOfThreads, StateManager stateMan) {
+        //create state-manager
+        final StateManager stateManager;
+        if (stateMan != null) {
+            stateManager = stateMan;
+        } else {
+            stateManager = new StateManager(vrp);
+        }
+        stateManager.updateLoadStates();
+        stateManager.updateTimeWindowStates();
+        stateManager.updateSkillStates();
+        stateManager.addStateUpdater(new UpdateEndLocationIfRouteIsOpen());
+        stateManager.addStateUpdater(new OpenRouteStateVerifier());
+//		stateManager.addStateUpdater(new UpdateActivityTimes(vrp.getTransportCosts()));
+//		stateManager.addStateUpdater(new UpdateVariableCosts(vrp.getActivityCosts(), vrp.getTransportCosts(), stateManager));
+
+		/*
+         * define constraints
+		 */
+        //constraint manager
+        ConstraintManager constraintManager = new ConstraintManager(vrp, stateManager);
+        constraintManager.addTimeWindowConstraint();
+        constraintManager.addLoadConstraint();
+        constraintManager.addSkillsConstraint();
+        constraintManager.addConstraint(new SwitchNotFeasible(stateManager));
+
+        return readAndCreateAlgorithm(vrp, config, nuOfThreads, null, stateManager, constraintManager, true);
+    }
+
+    public static VehicleRoutingAlgorithm readAndCreateAlgorithm(final VehicleRoutingProblem vrp, AlgorithmConfig config,
+                                                                 int nuOfThreads, SolutionCostCalculator solutionCostCalculator, final StateManager stateManager, ConstraintManager constraintManager, boolean addDefaultCostCalculators) {
+        return readAndCreateAlgorithm(vrp, config.getXMLConfiguration(), nuOfThreads, solutionCostCalculator, stateManager, constraintManager, addDefaultCostCalculators);
+    }
+
+    private static VehicleRoutingAlgorithm readAndCreateAlgorithm(final VehicleRoutingProblem vrp, XMLConfiguration config,
+                                                                  int nuOfThreads, final SolutionCostCalculator solutionCostCalculator, final StateManager stateManager, ConstraintManager constraintManager, boolean addDefaultCostCalculators) {
+        // map to store constructed modules
+        TypedMap definedClasses = new TypedMap();
+
+        // algorithm listeners
+        Set<PrioritizedVRAListener> algorithmListeners = new HashSet<PrioritizedVRAListener>();
+
+        // insertion listeners
+        List<InsertionListener> insertionListeners = new ArrayList<InsertionListener>();
+
+
+        //threading
+        final ExecutorService executorService;
+        if (nuOfThreads > 0) {
+            log.debug("setup executor-service with " + nuOfThreads + " threads");
+            executorService = Executors.newFixedThreadPool(nuOfThreads);
+            algorithmListeners.add(new PrioritizedVRAListener(Priority.LOW, new AlgorithmEndsListener() {
+
+                @Override
+                public void informAlgorithmEnds(VehicleRoutingProblem problem, Collection<VehicleRoutingProblemSolution> solutions) {
+                    log.debug("shutdown executor-service");
+                    executorService.shutdown();
+                }
+            }));
+            Thread.setDefaultUncaughtExceptionHandler(new UncaughtExceptionHandler() {
+
+                @Override
+                public void uncaughtException(Thread arg0, Throwable arg1) {
+                    System.err.println(arg1.toString());
+                }
+            });
+            Runtime.getRuntime().addShutdownHook(new Thread() {
+                public void run() {
+                    if (!executorService.isShutdown()) {
+                        System.err.println("shutdowHook shuts down executorService");
+                        executorService.shutdown();
+                    }
+                }
+            });
+        } else executorService = null;
+
+
+        //create fleetmanager
+        final VehicleFleetManager vehicleFleetManager = createFleetManager(vrp);
+
+        String switchString = config.getString("construction.insertion.allowVehicleSwitch");
+        final boolean switchAllowed;
+        if (switchString != null) {
+            switchAllowed = Boolean.parseBoolean(switchString);
+        } else switchAllowed = true;
+        ActivityTimeTracker.ActivityPolicy activityPolicy;
+        if (stateManager.timeWindowUpdateIsActivated()) {
+            UpdateVehicleDependentPracticalTimeWindows timeWindowUpdater = new UpdateVehicleDependentPracticalTimeWindows(stateManager, vrp.getTransportCosts(), vrp.getActivityCosts());
+            timeWindowUpdater.setVehiclesToUpdate(new UpdateVehicleDependentPracticalTimeWindows.VehiclesToUpdate() {
+                Map<VehicleTypeKey, Vehicle> uniqueTypes = new HashMap<VehicleTypeKey, Vehicle>();
+
+                @Override
+                public Collection<Vehicle> get(VehicleRoute vehicleRoute) {
+                    if (uniqueTypes.isEmpty()) {
+                        for (Vehicle v : vrp.getVehicles()) {
+                            if (!uniqueTypes.containsKey(v.getVehicleTypeIdentifier())) {
+                                uniqueTypes.put(v.getVehicleTypeIdentifier(), v);
+                            }
+                        }
+                    }
+                    Collection<Vehicle> vehicles = new ArrayList<Vehicle>();
+                    vehicles.addAll(uniqueTypes.values());
+                    return vehicles;
+                }
+            });
+            stateManager.addStateUpdater(timeWindowUpdater);
+            activityPolicy = ActivityTimeTracker.ActivityPolicy.AS_SOON_AS_TIME_WINDOW_OPENS;
+        } else {
+            activityPolicy = ActivityTimeTracker.ActivityPolicy.AS_SOON_AS_ARRIVED;
+        }
+        stateManager.addStateUpdater(new UpdateActivityTimes(vrp.getTransportCosts(), activityPolicy, vrp.getActivityCosts()));
+        stateManager.addStateUpdater(new UpdateVariableCosts(vrp.getActivityCosts(), vrp.getTransportCosts(), stateManager, activityPolicy));
+
+        final SolutionCostCalculator costCalculator;
+        if (solutionCostCalculator == null) costCalculator = getDefaultCostCalculator(stateManager);
+        else costCalculator = solutionCostCalculator;
+
+        PrettyAlgorithmBuilder prettyAlgorithmBuilder = PrettyAlgorithmBuilder.newInstance(vrp, vehicleFleetManager, stateManager, constraintManager);
+        //construct initial solution creator
+        final InsertionStrategy initialInsertionStrategy = createInitialSolution(config, vrp, vehicleFleetManager, stateManager, algorithmListeners, definedClasses, executorService, nuOfThreads, costCalculator, constraintManager, addDefaultCostCalculators);
+        if (initialInsertionStrategy != null)
+            prettyAlgorithmBuilder.constructInitialSolutionWith(initialInsertionStrategy, costCalculator);
+
+        //construct algorithm, i.e. search-strategies and its modules
+        int solutionMemory = config.getInt("strategy.memory");
+        List<HierarchicalConfiguration> strategyConfigs = config.configurationsAt("strategy.searchStrategies.searchStrategy");
+        for (HierarchicalConfiguration strategyConfig : strategyConfigs) {
+            String name = getName(strategyConfig);
+            SolutionAcceptor acceptor = getAcceptor(strategyConfig, vrp, algorithmListeners, definedClasses, solutionMemory);
+            SolutionSelector selector = getSelector(strategyConfig, vrp, algorithmListeners, definedClasses);
+
+            SearchStrategy strategy = new SearchStrategy(name, selector, acceptor, costCalculator);
+            strategy.setName(name);
+            List<HierarchicalConfiguration> modulesConfig = strategyConfig.configurationsAt("modules.module");
+            for (HierarchicalConfiguration moduleConfig : modulesConfig) {
+                SearchStrategyModule module = buildModule(moduleConfig, vrp, vehicleFleetManager, stateManager, algorithmListeners, definedClasses, executorService, nuOfThreads, constraintManager, addDefaultCostCalculators);
+                strategy.addModule(module);
+            }
+            prettyAlgorithmBuilder.withStrategy(strategy, strategyConfig.getDouble("probability"));
+        }
+
+        //construct algorithm
+        VehicleRoutingAlgorithm metaAlgorithm = prettyAlgorithmBuilder.build();
+        int maxIterations = getMaxIterations(config);
+        if (maxIterations > -1) metaAlgorithm.setMaxIterations(maxIterations);
+
+        //define prematureBreak
+        PrematureAlgorithmTermination prematureAlgorithmTermination = getPrematureTermination(config, algorithmListeners);
+        if (prematureAlgorithmTermination != null)
+            metaAlgorithm.setPrematureAlgorithmTermination(prematureAlgorithmTermination);
+        else {
+            List<HierarchicalConfiguration> terminationCriteria = config.configurationsAt("terminationCriteria.termination");
+            for (HierarchicalConfiguration terminationConfig : terminationCriteria) {
+                PrematureAlgorithmTermination termination = getTerminationCriterion(terminationConfig, algorithmListeners);
+                if (termination != null) metaAlgorithm.addTerminationCriterion(termination);
+            }
+        }
+        for (PrioritizedVRAListener l : algorithmListeners) {
+            metaAlgorithm.getAlgorithmListeners().add(l);
+        }
+        return metaAlgorithm;
+    }
+
+    private static int getMaxIterations(XMLConfiguration config) {
+        String maxIterationsString = config.getString("iterations");
+        if (maxIterationsString == null) maxIterationsString = config.getString("maxIterations");
+        if (maxIterationsString != null) return (Integer.parseInt(maxIterationsString));
+        return -1;
+    }
+
+    private static SolutionCostCalculator getDefaultCostCalculator(final StateManager stateManager) {
+        return new VariablePlusFixedSolutionCostCalculatorFactory(stateManager).createCalculator();
+    }
+
+    private static VehicleFleetManager createFleetManager(final VehicleRoutingProblem vrp) {
+        if (vrp.getFleetSize().equals(FleetSize.INFINITE)) {
+            return new InfiniteFleetManagerFactory(vrp.getVehicles()).createFleetManager();
+
+        } else if (vrp.getFleetSize().equals(FleetSize.FINITE)) {
+            return new FiniteFleetManagerFactory(vrp.getVehicles()).createFleetManager();
+        }
+        throw new IllegalStateException("fleet size can only be infinite or finite. " +
+            "makes sure your config file contains one of these options");
+    }
+
+    private static PrematureAlgorithmTermination getTerminationCriterion(HierarchicalConfiguration config, Set<PrioritizedVRAListener> algorithmListeners) {
+        String basedOn = config.getString("[@basedOn]");
+        if (basedOn == null) {
+            log.debug("set default prematureBreak, i.e. no premature break at all.");
+            return null;
+        }
+        if (basedOn.equals("iterations")) {
+            log.debug("set prematureBreak based on iterations");
+            String iter = config.getString("iterations");
+            if (iter == null) throw new IllegalStateException("iterations is missing");
+            int iterations = Integer.valueOf(iter);
+            return new IterationWithoutImprovementTermination(iterations);
+        }
+        if (basedOn.equals("time")) {
+            log.debug("set prematureBreak based on time");
+            String timeString = config.getString("time");
+            if (timeString == null) throw new IllegalStateException("time is missing");
+            long time = Long.parseLong(timeString);
+            TimeTermination timeBreaker = new TimeTermination(time);
+            algorithmListeners.add(new PrioritizedVRAListener(Priority.LOW, timeBreaker));
+            return timeBreaker;
+        }
+        if (basedOn.equals("variationCoefficient")) {
+            log.debug("set prematureBreak based on variation coefficient");
+            String thresholdString = config.getString("threshold");
+            String iterationsString = config.getString("iterations");
+            if (thresholdString == null) throw new IllegalStateException("threshold is missing");
+            if (iterationsString == null) throw new IllegalStateException("iterations is missing");
+            double threshold = Double.valueOf(thresholdString);
+            int iterations = Integer.valueOf(iterationsString);
+            VariationCoefficientTermination variationCoefficientBreaker = new VariationCoefficientTermination(iterations, threshold);
+            algorithmListeners.add(new PrioritizedVRAListener(Priority.LOW, variationCoefficientBreaker));
+            return variationCoefficientBreaker;
+        }
+        throw new IllegalStateException("prematureBreak basedOn " + basedOn + " is not defined");
+    }
+
+    private static PrematureAlgorithmTermination getPrematureTermination(XMLConfiguration config, Set<PrioritizedVRAListener> algorithmListeners) {
+        String basedOn = config.getString("prematureBreak[@basedOn]");
+        if (basedOn == null) {
+            log.debug("set default prematureBreak, i.e. no premature break at all.");
+            return null;
+        }
+        if (basedOn.equals("iterations")) {
+            log.debug("set prematureBreak based on iterations");
+            String iter = config.getString("prematureBreak.iterations");
+            if (iter == null) throw new IllegalStateException("prematureBreak.iterations is missing");
+            int iterations = Integer.valueOf(iter);
+            return new IterationWithoutImprovementTermination(iterations);
+        }
+        if (basedOn.equals("time")) {
+            log.debug("set prematureBreak based on time");
+            String timeString = config.getString("prematureBreak.time");
+            if (timeString == null) throw new IllegalStateException("prematureBreak.time is missing");
+            long time = Long.parseLong(timeString);
+            TimeTermination timeBreaker = new TimeTermination(time);
+            algorithmListeners.add(new PrioritizedVRAListener(Priority.LOW, timeBreaker));
+            return timeBreaker;
+        }
+        if (basedOn.equals("variationCoefficient")) {
+            log.debug("set prematureBreak based on variation coefficient");
+            String thresholdString = config.getString("prematureBreak.threshold");
+            String iterationsString = config.getString("prematureBreak.iterations");
+            if (thresholdString == null) throw new IllegalStateException("prematureBreak.threshold is missing");
+            if (iterationsString == null) throw new IllegalStateException("prematureBreak.iterations is missing");
+            double threshold = Double.valueOf(thresholdString);
+            int iterations = Integer.valueOf(iterationsString);
+            VariationCoefficientTermination variationCoefficientBreaker = new VariationCoefficientTermination(iterations, threshold);
+            algorithmListeners.add(new PrioritizedVRAListener(Priority.LOW, variationCoefficientBreaker));
+            return variationCoefficientBreaker;
+        }
+        throw new IllegalStateException("prematureBreak basedOn " + basedOn + " is not defined");
+    }
+
+    private static String getName(HierarchicalConfiguration strategyConfig) {
+        if (strategyConfig.containsKey("[@name]")) {
+            return strategyConfig.getString("[@name]");
+        }
+        return "";
+    }
+
+    private static InsertionStrategy createInitialSolution(XMLConfiguration config, final VehicleRoutingProblem vrp, VehicleFleetManager vehicleFleetManager, final StateManager routeStates, Set<PrioritizedVRAListener> algorithmListeners, TypedMap definedClasses, ExecutorService executorService, int nuOfThreads, final SolutionCostCalculator solutionCostCalculator, ConstraintManager constraintManager, boolean addDefaultCostCalculators) {
+        List<HierarchicalConfiguration> modConfigs = config.configurationsAt("construction.insertion");
+        if (modConfigs == null) return null;
+        if (modConfigs.isEmpty()) return null;
+        if (modConfigs.size() != 1) throw new IllegalStateException("#construction.modules != 1. 1 expected");
+        HierarchicalConfiguration modConfig = modConfigs.get(0);
+        String insertionName = modConfig.getString("[@name]");
+        if (insertionName == null) throw new IllegalStateException("insertion[@name] is missing.");
+        String insertionId = modConfig.getString("[@id]");
+        if (insertionId == null) insertionId = "noId";
+        ModKey modKey = makeKey(insertionName, insertionId);
+        InsertionStrategyKey insertionStrategyKey = new InsertionStrategyKey(modKey);
+        InsertionStrategy insertionStrategy = definedClasses.get(insertionStrategyKey);
+        if (insertionStrategy == null) {
+            List<PrioritizedVRAListener> prioListeners = new ArrayList<PrioritizedVRAListener>();
+            insertionStrategy = createInsertionStrategy(modConfig, vrp, vehicleFleetManager, routeStates, prioListeners, executorService, nuOfThreads, constraintManager, addDefaultCostCalculators);
+            algorithmListeners.addAll(prioListeners);
+            definedClasses.put(insertionStrategyKey, insertionStrategy);
+        }
+        return insertionStrategy;
+    }
+
+    private static SolutionSelector getSelector(HierarchicalConfiguration strategyConfig, VehicleRoutingProblem vrp, Set<PrioritizedVRAListener> algorithmListeners, TypedMap definedSelectors) {
+        String selectorName = strategyConfig.getString("selector[@name]");
+        if (selectorName == null)
+            throw new IllegalStateException("no solutionSelector defined. define either \"selectRandomly\" or \"selectBest\"");
+        String selectorId = strategyConfig.getString("selector[@id]");
+        if (selectorId == null) selectorId = "noId";
+        ModKey modKey = makeKey(selectorName, selectorId);
+        SelectorKey selectorKey = new SelectorKey(modKey);
+        SolutionSelector definedSelector = definedSelectors.get(selectorKey);
+        if (definedSelector != null) {
+            return definedSelector;
+        }
+        if (selectorName.equals("selectRandomly")) {
+            SelectRandomly selector = SelectRandomly.getInstance();
+            definedSelectors.put(selectorKey, selector);
+            return selector;
+        }
+        if (selectorName.equals("selectBest")) {
+            SelectBest selector = SelectBest.getInstance();
+            definedSelectors.put(selectorKey, selector);
+            return selector;
+        }
+        throw new IllegalStateException("solutionSelector is not know. Currently, it only knows \"selectRandomly\" and \"selectBest\"");
+    }
+
+    private static ModKey makeKey(String name, String id) {
+        return new ModKey(name, id);
+    }
+
+    private static SolutionAcceptor getAcceptor(HierarchicalConfiguration strategyConfig, VehicleRoutingProblem vrp, Set<PrioritizedVRAListener> algorithmListeners, TypedMap typedMap, int solutionMemory) {
+        String acceptorName = strategyConfig.getString("acceptor[@name]");
+        if (acceptorName == null) throw new IllegalStateException("no solution acceptor is defined");
+        String acceptorId = strategyConfig.getString("acceptor[@id]");
+        if (acceptorId == null) acceptorId = "noId";
+        AcceptorKey acceptorKey = new AcceptorKey(makeKey(acceptorName, acceptorId));
+        SolutionAcceptor definedAcceptor = typedMap.get(acceptorKey);
+        if (definedAcceptor != null) return definedAcceptor;
+        if (acceptorName.equals("acceptNewRemoveWorst")) {
+            GreedyAcceptance acceptor = new GreedyAcceptance(solutionMemory);
+            typedMap.put(acceptorKey, acceptor);
+            return acceptor;
+        }
+        if (acceptorName.equals("acceptNewRemoveFirst")) {
+            AcceptNewRemoveFirst acceptor = new AcceptNewRemoveFirst(solutionMemory);
+            typedMap.put(acceptorKey, acceptor);
+            return acceptor;
+        }
+        if (acceptorName.equals("greedyAcceptance")) {
+            GreedyAcceptance acceptor = new GreedyAcceptance(solutionMemory);
+            typedMap.put(acceptorKey, acceptor);
+            return acceptor;
+        }
+        if (acceptorName.equals("schrimpfAcceptance")) {
+            String nuWarmupIterations = strategyConfig.getString("acceptor.warmup");
+            double alpha = strategyConfig.getDouble("acceptor.alpha");
+            SchrimpfAcceptance schrimpf = new SchrimpfAcceptance(solutionMemory, alpha);
+            if (nuWarmupIterations != null) {
+                SchrimpfInitialThresholdGenerator iniThresholdGenerator = new SchrimpfInitialThresholdGenerator(schrimpf, Integer.parseInt(nuWarmupIterations));
+                algorithmListeners.add(new PrioritizedVRAListener(Priority.LOW, iniThresholdGenerator));
+            } else {
+                double threshold = strategyConfig.getDouble("acceptor.initialThreshold");
+                schrimpf.setInitialThreshold(threshold);
+            }
+            algorithmListeners.add(new PrioritizedVRAListener(Priority.LOW, schrimpf));
+            typedMap.put(acceptorKey, schrimpf);
+            return schrimpf;
+        }
+        if (acceptorName.equals("experimentalSchrimpfAcceptance")) {
+            int iterOfSchrimpf = strategyConfig.getInt("acceptor.warmup");
+            double alpha = strategyConfig.getDouble("acceptor.alpha");
+            ExperimentalSchrimpfAcceptance schrimpf = new ExperimentalSchrimpfAcceptance(solutionMemory, alpha, iterOfSchrimpf);
+            algorithmListeners.add(new PrioritizedVRAListener(Priority.LOW, schrimpf));
+            typedMap.put(acceptorKey, schrimpf);
+            return schrimpf;
+        } else {
+            throw new IllegalStateException("solution acceptor " + acceptorName + " is not known");
+        }
+    }
+
+    private static SearchStrategyModule buildModule(HierarchicalConfiguration moduleConfig, final VehicleRoutingProblem vrp, VehicleFleetManager vehicleFleetManager,
+                                                    final StateManager routeStates, Set<PrioritizedVRAListener> algorithmListeners, TypedMap definedClasses, ExecutorService executorService, int nuOfThreads, ConstraintManager constraintManager, boolean addDefaultCostCalculators) {
+        String moduleName = moduleConfig.getString("[@name]");
+        if (moduleName == null) throw new IllegalStateException("module(-name) is missing.");
+        String moduleId = moduleConfig.getString("[@id]");
+        if (moduleId == null) moduleId = "noId";
+        ModKey modKey = makeKey(moduleName, moduleId);
+        StrategyModuleKey strategyModuleKey = new StrategyModuleKey(modKey);
+        SearchStrategyModule definedModule = definedClasses.get(strategyModuleKey);
+        if (definedModule != null) return definedModule;
+
+        if (moduleName.equals("ruin_and_recreate")) {
+            String ruin_name = moduleConfig.getString("ruin[@name]");
+            if (ruin_name == null) throw new IllegalStateException("module.ruin[@name] is missing.");
+            String ruin_id = moduleConfig.getString("ruin[@id]");
+            if (ruin_id == null) ruin_id = "noId";
+            String shareToRuinString = moduleConfig.getString("ruin.share");
+            if (shareToRuinString == null) throw new IllegalStateException("module.ruin.share is missing.");
+            double shareToRuin = Double.valueOf(shareToRuinString);
+            final RuinStrategy ruin;
+            ModKey ruinKey = makeKey(ruin_name, ruin_id);
+            if (ruin_name.equals("randomRuin")) {
+                ruin = getRandomRuin(vrp, routeStates, definedClasses, ruinKey, shareToRuin);
+            } else if (ruin_name.equals("radialRuin")) {
+                JobDistance jobDistance = new AvgServiceAndShipmentDistance(vrp.getTransportCosts());
+                ruin = getRadialRuin(vrp, routeStates, definedClasses, ruinKey, shareToRuin, jobDistance);
+            } else
+                throw new IllegalStateException("ruin[@name] " + ruin_name + " is not known. Use either randomRuin or radialRuin.");
+
+            String insertionName = moduleConfig.getString("insertion[@name]");
+            if (insertionName == null)
+                throw new IllegalStateException("module.insertion[@name] is missing. set it to \"regretInsertion\" or \"bestInsertion\"");
+            String insertionId = moduleConfig.getString("insertion[@id]");
+            if (insertionId == null) insertionId = "noId";
+            ModKey insertionKey = makeKey(insertionName, insertionId);
+            InsertionStrategyKey insertionStrategyKey = new InsertionStrategyKey(insertionKey);
+            InsertionStrategy insertion = definedClasses.get(insertionStrategyKey);
+            if (insertion == null) {
+                List<HierarchicalConfiguration> insertionConfigs = moduleConfig.configurationsAt("insertion");
+                if (insertionConfigs.size() != 1) throw new IllegalStateException("this should be 1");
+                List<PrioritizedVRAListener> prioListeners = new ArrayList<PrioritizedVRAListener>();
+                insertion = createInsertionStrategy(insertionConfigs.get(0), vrp, vehicleFleetManager, routeStates, prioListeners, executorService, nuOfThreads, constraintManager, addDefaultCostCalculators);
+                algorithmListeners.addAll(prioListeners);
+            }
+            final InsertionStrategy final_insertion = insertion;
+
+            RuinAndRecreateModule rrModule = new RuinAndRecreateModule("ruin_and_recreate", final_insertion, ruin);
+            return rrModule;
+        }
+        throw new NullPointerException("no module found with moduleName=" + moduleName +
+            "\n\tcheck config whether the correct names are used" +
+            "\n\tcurrently there are following modules available: " +
+            "\n\tbestInsertion" +
+            "\n\trandomRuin" +
+            "\n\tradialRuin");
+    }
+
+    private static RuinStrategy getRadialRuin(final VehicleRoutingProblem vrp, final StateManager routeStates, TypedMap definedClasses, ModKey modKey, double shareToRuin, JobDistance jobDistance) {
+        RuinStrategyKey stratKey = new RuinStrategyKey(modKey);
+        RuinStrategy ruin = definedClasses.get(stratKey);
+        if (ruin == null) {
+            ruin = new RadialRuinStrategyFactory(shareToRuin, jobDistance).createStrategy(vrp);
+            definedClasses.put(stratKey, ruin);
+        }
+        return ruin;
+    }
+
+    private static RuinStrategy getRandomRuin(final VehicleRoutingProblem vrp, final StateManager routeStates, TypedMap definedClasses, ModKey modKey, double shareToRuin) {
+        RuinStrategyKey stratKey = new RuinStrategyKey(modKey);
+        RuinStrategy ruin = definedClasses.get(stratKey);
+        if (ruin == null) {
+            ruin = new RandomRuinStrategyFactory(shareToRuin).createStrategy(vrp);
+            definedClasses.put(stratKey, ruin);
+        }
+        return ruin;
+    }
+
+    private static InsertionStrategy createInsertionStrategy(HierarchicalConfiguration moduleConfig, VehicleRoutingProblem vrp, VehicleFleetManager vehicleFleetManager, StateManager routeStates, List<PrioritizedVRAListener> algorithmListeners, ExecutorService executorService, int nuOfThreads, ConstraintManager constraintManager, boolean addDefaultCostCalculators) {
+        return InsertionFactory.createInsertion(vrp, moduleConfig, vehicleFleetManager, routeStates, algorithmListeners, executorService, nuOfThreads, constraintManager, addDefaultCostCalculators);
+    }
+
+
+}

jsprit-io/src/main/java/com/graphhopper/jsprit/io/problem/Schema.java

@@ -0,0 +1,65 @@
+/*******************************************************************************
+ * 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 com.graphhopper.jsprit.io.problem;
+
+final class Schema {
+
+    public static final String PROBLEM = "problem";
+    public static final String VEHICLE = "vehicle";
+    public static final String TYPES = "vehicleTypes";
+    public static final String VEHICLES = "vehicles";
+    public static final String SHIPMENTS = "shipments";
+    public static final String SHIPMENT = "shipment";
+    public static final String SERVICETIME = "serviceTime";
+    public static final String PICKUP = "pickup";
+    public static final String TYPE = "type";
+
+
+    public void dot() {
+
+    }
+
+    public static class PathBuilder {
+
+        StringBuilder stringBuilder = new StringBuilder();
+        boolean justCreated = true;
+
+
+        public PathBuilder dot(String string) {
+            stringBuilder.append(".").append(string);
+            return this;
+        }
+
+        public PathBuilder append(String string) {
+            stringBuilder.append(string);
+            return this;
+        }
+
+        public String build() {
+            return stringBuilder.toString();
+        }
+
+    }
+
+    public static PathBuilder builder() {
+        return new PathBuilder();
+    }
+
+    private Schema() {
+
+    }
+}

jsprit-io/src/main/java/com/graphhopper/jsprit/io/problem/VrpXMLReader.java

@@ -0,0 +1,721 @@
+/*******************************************************************************
+ * 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/>.
+ ******************************************************************************/
+package com.graphhopper.jsprit.io.problem;
+
+import com.graphhopper.jsprit.core.problem.Location;
+import com.graphhopper.jsprit.core.problem.VehicleRoutingProblem;
+import com.graphhopper.jsprit.core.problem.VehicleRoutingProblem.FleetSize;
+import com.graphhopper.jsprit.core.problem.driver.Driver;
+import com.graphhopper.jsprit.core.problem.driver.DriverImpl;
+import com.graphhopper.jsprit.core.problem.job.*;
+import com.graphhopper.jsprit.core.problem.solution.VehicleRoutingProblemSolution;
+import com.graphhopper.jsprit.core.problem.solution.route.VehicleRoute;
+import com.graphhopper.jsprit.core.problem.solution.route.activity.TimeWindow;
+import com.graphhopper.jsprit.core.problem.vehicle.Vehicle;
+import com.graphhopper.jsprit.core.problem.vehicle.VehicleImpl;
+import com.graphhopper.jsprit.core.problem.vehicle.VehicleImpl.Builder;
+import com.graphhopper.jsprit.core.problem.vehicle.VehicleType;
+import com.graphhopper.jsprit.core.problem.vehicle.VehicleTypeImpl;
+import com.graphhopper.jsprit.core.util.Coordinate;
+import com.graphhopper.jsprit.core.util.Resource;
+import org.apache.commons.configuration.ConfigurationException;
+import org.apache.commons.configuration.HierarchicalConfiguration;
+import org.apache.commons.configuration.XMLConfiguration;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.xml.sax.EntityResolver;
+import org.xml.sax.InputSource;
+import org.xml.sax.SAXException;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.*;
+
+public class VrpXMLReader {
+
+    public interface ServiceBuilderFactory {
+        Service.Builder createBuilder(String serviceType, String id, Integer size);
+    }
+
+    static class DefaultServiceBuilderFactory implements ServiceBuilderFactory {
+
+        @Override
+        public Service.Builder createBuilder(String serviceType, String id, Integer size) {
+            if (serviceType.equals("pickup")) {
+                if (size != null) return Pickup.Builder.newInstance(id).addSizeDimension(0, size);
+                else return Pickup.Builder.newInstance(id);
+            } else if (serviceType.equals("delivery")) {
+                if (size != null) return Delivery.Builder.newInstance(id).addSizeDimension(0, size);
+                else return Delivery.Builder.newInstance(id);
+            } else {
+                if (size != null) return Service.Builder.newInstance(id).addSizeDimension(0, size);
+                else return Service.Builder.newInstance(id);
+
+            }
+        }
+    }
+
+    private static Logger logger = LoggerFactory.getLogger(VrpXMLReader.class);
+
+    private VehicleRoutingProblem.Builder vrpBuilder;
+
+    private Map<String, Vehicle> vehicleMap;
+
+    private Map<String, Service> serviceMap;
+
+    private Map<String, Shipment> shipmentMap;
+
+    private Set<String> freezedJobIds = new HashSet<String>();
+
+    private boolean schemaValidation = true;
+
+    private Collection<VehicleRoutingProblemSolution> solutions;
+
+    private ServiceBuilderFactory serviceBuilderFactory = new DefaultServiceBuilderFactory();
+
+
+
+    /**
+     * @param schemaValidation the schemaValidation to set
+     */
+    @SuppressWarnings("UnusedDeclaration")
+    public void setSchemaValidation(boolean schemaValidation) {
+        this.schemaValidation = schemaValidation;
+    }
+
+    public VrpXMLReader(VehicleRoutingProblem.Builder vrpBuilder, Collection<VehicleRoutingProblemSolution> solutions) {
+        this.vrpBuilder = vrpBuilder;
+        this.vehicleMap = new LinkedHashMap<String, Vehicle>();
+        this.serviceMap = new LinkedHashMap<String, Service>();
+        this.shipmentMap = new LinkedHashMap<String, Shipment>();
+        this.solutions = solutions;
+    }
+
+    public VrpXMLReader(VehicleRoutingProblem.Builder vrpBuilder) {
+        this.vrpBuilder = vrpBuilder;
+        this.vehicleMap = new LinkedHashMap<String, Vehicle>();
+        this.serviceMap = new LinkedHashMap<String, Service>();
+        this.shipmentMap = new LinkedHashMap<String, Shipment>();
+        this.solutions = null;
+    }
+
+    public void read(String filename) {
+        logger.debug("read vrp: {}", filename);
+        XMLConfiguration xmlConfig = createXMLConfiguration();
+        try {
+            xmlConfig.load(filename);
+        } catch (ConfigurationException e) {
+            throw new RuntimeException(e);
+        }
+        read(xmlConfig);
+    }
+
+    public void read(InputStream fileContents) {
+        XMLConfiguration xmlConfig = createXMLConfiguration();
+        try {
+            xmlConfig.load(fileContents);
+        } catch (ConfigurationException e) {
+            throw new RuntimeException(e);
+        }
+        read(xmlConfig);
+    }
+
+    private XMLConfiguration createXMLConfiguration() {
+        XMLConfiguration xmlConfig = new XMLConfiguration();
+        xmlConfig.setAttributeSplittingDisabled(true);
+        xmlConfig.setDelimiterParsingDisabled(true);
+
+        if (schemaValidation) {
+            final InputStream resource = Resource.getAsInputStream("vrp_xml_schema.xsd");
+            if (resource != null) {
+                EntityResolver resolver = new EntityResolver() {
+
+                    @Override
+                    public InputSource resolveEntity(String publicId, String systemId) throws SAXException, IOException {
+                        {
+                            InputSource is = new InputSource(resource);
+                            return is;
+                        }
+                    }
+                };
+                xmlConfig.setEntityResolver(resolver);
+                xmlConfig.setSchemaValidation(true);
+            } else {
+                logger.debug("cannot find schema-xsd file (vrp_xml_schema.xsd). try to read xml without xml-file-validation.");
+            }
+        }
+        return xmlConfig;
+    }
+
+    private void read(XMLConfiguration xmlConfig) {
+        readProblemType(xmlConfig);
+        readVehiclesAndTheirTypes(xmlConfig);
+
+        readShipments(xmlConfig);
+        readServices(xmlConfig);
+
+        readInitialRoutes(xmlConfig);
+        readSolutions(xmlConfig);
+
+        addJobsAndTheirLocationsToVrp();
+    }
+
+    private void addJobsAndTheirLocationsToVrp() {
+        for (Service service : serviceMap.values()) {
+            if (!freezedJobIds.contains(service.getId())) {
+                vrpBuilder.addJob(service);
+            }
+        }
+        for (Shipment shipment : shipmentMap.values()) {
+            if (!freezedJobIds.contains(shipment.getId())) {
+                vrpBuilder.addJob(shipment);
+            }
+        }
+    }
+
+    private void readInitialRoutes(XMLConfiguration xmlConfig) {
+        List<HierarchicalConfiguration> initialRouteConfigs = xmlConfig.configurationsAt("initialRoutes.route");
+        for (HierarchicalConfiguration routeConfig : initialRouteConfigs) {
+            Driver driver = DriverImpl.noDriver();
+            String vehicleId = routeConfig.getString("vehicleId");
+            Vehicle vehicle = getVehicle(vehicleId);
+            if (vehicle == null) throw new IllegalArgumentException("vehicle is missing.");
+            String start = routeConfig.getString("start");
+            if (start == null) throw new IllegalArgumentException("route start-time is missing.");
+            double departureTime = Double.parseDouble(start);
+
+            VehicleRoute.Builder routeBuilder = VehicleRoute.Builder.newInstance(vehicle, driver);
+            routeBuilder.setDepartureTime(departureTime);
+
+            List<HierarchicalConfiguration> actConfigs = routeConfig.configurationsAt("act");
+            for (HierarchicalConfiguration actConfig : actConfigs) {
+                String type = actConfig.getString("[@type]");
+                if (type == null) throw new IllegalArgumentException("act[@type] is missing.");
+                double arrTime = 0.;
+                double endTime = 0.;
+                String arrTimeS = actConfig.getString("arrTime");
+                if (arrTimeS != null) arrTime = Double.parseDouble(arrTimeS);
+                String endTimeS = actConfig.getString("endTime");
+                if (endTimeS != null) endTime = Double.parseDouble(endTimeS);
+
+                String serviceId = actConfig.getString("serviceId");
+                if(type.equals("break")) {
+                    Break currentbreak = getBreak(vehicleId);
+                    routeBuilder.addBreak(currentbreak);
+                }
+                else {
+                    if (serviceId != null) {
+                        Service service = getService(serviceId);
+                        if (service == null)
+                            throw new IllegalArgumentException("service to serviceId " + serviceId + " is missing (reference in one of your initial routes). make sure you define the service you refer to here in <services> </services>.");
+                        //!!!since job is part of initial route, it does not belong to jobs in problem, i.e. variable jobs that can be assigned/scheduled
+                        freezedJobIds.add(serviceId);
+                        routeBuilder.addService(service);
+                    } else {
+                        String shipmentId = actConfig.getString("shipmentId");
+                        if (shipmentId == null)
+                            throw new IllegalArgumentException("either serviceId or shipmentId is missing");
+                        Shipment shipment = getShipment(shipmentId);
+                        if (shipment == null)
+                            throw new IllegalArgumentException("shipment to shipmentId " + shipmentId + " is missing (reference in one of your initial routes). make sure you define the shipment you refer to here in <shipments> </shipments>.");
+                        freezedJobIds.add(shipmentId);
+                        if (type.equals("pickupShipment")) {
+                            routeBuilder.addPickup(shipment);
+                        } else if (type.equals("deliverShipment")) {
+                            routeBuilder.addDelivery(shipment);
+                        } else
+                            throw new IllegalArgumentException("type " + type + " is not supported. Use 'pickupShipment' or 'deliverShipment' here");
+                    }
+                }
+            }
+            VehicleRoute route = routeBuilder.build();
+            vrpBuilder.addInitialVehicleRoute(route);
+        }
+
+    }
+
+    private void readSolutions(XMLConfiguration vrpProblem) {
+        if (solutions == null) return;
+        List<HierarchicalConfiguration> solutionConfigs = vrpProblem.configurationsAt("solutions.solution");
+        for (HierarchicalConfiguration solutionConfig : solutionConfigs) {
+            String totalCost = solutionConfig.getString("cost");
+            double cost = -1;
+            if (totalCost != null) cost = Double.parseDouble(totalCost);
+            List<HierarchicalConfiguration> routeConfigs = solutionConfig.configurationsAt("routes.route");
+            List<VehicleRoute> routes = new ArrayList<VehicleRoute>();
+            for (HierarchicalConfiguration routeConfig : routeConfigs) {
+                //! here, driverId is set to noDriver, no matter whats in driverId.
+                Driver driver = DriverImpl.noDriver();
+                String vehicleId = routeConfig.getString("vehicleId");
+                Vehicle vehicle = getVehicle(vehicleId);
+                if (vehicle == null) throw new IllegalArgumentException("vehicle is missing.");
+                String start = routeConfig.getString("start");
+                if (start == null) throw new IllegalArgumentException("route start-time is missing.");
+                double departureTime = Double.parseDouble(start);
+
+                String end = routeConfig.getString("end");
+                if (end == null) throw new IllegalArgumentException("route end-time is missing.");
+
+                VehicleRoute.Builder routeBuilder = VehicleRoute.Builder.newInstance(vehicle, driver);
+                routeBuilder.setDepartureTime(departureTime);
+                List<HierarchicalConfiguration> actConfigs = routeConfig.configurationsAt("act");
+                for (HierarchicalConfiguration actConfig : actConfigs) {
+                    String type = actConfig.getString("[@type]");
+                    if (type == null) throw new IllegalArgumentException("act[@type] is missing.");
+                    double arrTime = 0.;
+                    double endTime = 0.;
+                    String arrTimeS = actConfig.getString("arrTime");
+                    if (arrTimeS != null) arrTime = Double.parseDouble(arrTimeS);
+                    String endTimeS = actConfig.getString("endTime");
+                    if (endTimeS != null) endTime = Double.parseDouble(endTimeS);
+                    if(type.equals("break")) {
+                        Break currentbreak = getBreak(vehicleId);
+                        routeBuilder.addBreak(currentbreak);
+                    }
+                    else {
+                        String serviceId = actConfig.getString("serviceId");
+                        if (serviceId != null) {
+                            Service service = getService(serviceId);
+                            routeBuilder.addService(service);
+                        } else {
+                            String shipmentId = actConfig.getString("shipmentId");
+                            if (shipmentId == null)
+                                throw new IllegalArgumentException("either serviceId or shipmentId is missing");
+                            Shipment shipment = getShipment(shipmentId);
+                            if (shipment == null)
+                                throw new IllegalArgumentException("shipment with id " + shipmentId + " does not exist.");
+                            if (type.equals("pickupShipment")) {
+                                routeBuilder.addPickup(shipment);
+                            } else if (type.equals("deliverShipment")) {
+                                routeBuilder.addDelivery(shipment);
+                            } else
+                                throw new IllegalArgumentException("type " + type + " is not supported. Use 'pickupShipment' or 'deliverShipment' here");
+                        }
+                    }
+                }
+                routes.add(routeBuilder.build());
+            }
+            VehicleRoutingProblemSolution solution = new VehicleRoutingProblemSolution(routes, cost);
+            List<HierarchicalConfiguration> unassignedJobConfigs = solutionConfig.configurationsAt("unassignedJobs.job");
+            for (HierarchicalConfiguration unassignedJobConfig : unassignedJobConfigs) {
+                String jobId = unassignedJobConfig.getString("[@id]");
+                Job job = getShipment(jobId);
+                if (job == null) job = getService(jobId);
+                if (job == null) throw new IllegalArgumentException("cannot find unassignedJob with id " + jobId);
+                solution.getUnassignedJobs().add(job);
+            }
+
+            solutions.add(solution);
+        }
+    }
+
+    private Shipment getShipment(String shipmentId) {
+        return shipmentMap.get(shipmentId);
+    }
+
+    private Service getService(String serviceId) {
+        return serviceMap.get(serviceId);
+    }
+
+    private Vehicle getVehicle(String vehicleId) {
+        return vehicleMap.get(vehicleId);
+    }
+
+    private Break getBreak(String vehicleId) {
+        return vehicleMap.get(vehicleId).getBreak();
+    }
+
+    private void readProblemType(XMLConfiguration vrpProblem) {
+        String fleetSize = vrpProblem.getString("problemType.fleetSize");
+        if (fleetSize == null) vrpBuilder.setFleetSize(FleetSize.INFINITE);
+        else if (fleetSize.toUpperCase().equals(FleetSize.INFINITE.toString()))
+            vrpBuilder.setFleetSize(FleetSize.INFINITE);
+        else vrpBuilder.setFleetSize(FleetSize.FINITE);
+    }
+
+    private void readShipments(XMLConfiguration config) {
+        List<HierarchicalConfiguration> shipmentConfigs = config.configurationsAt("shipments.shipment");
+        for (HierarchicalConfiguration shipmentConfig : shipmentConfigs) {
+            String id = shipmentConfig.getString("[@id]");
+            if (id == null) throw new IllegalArgumentException("shipment[@id] is missing.");
+
+            String capacityString = shipmentConfig.getString("capacity-demand");
+            boolean capacityDimensionsExist = shipmentConfig.containsKey("capacity-dimensions.dimension(0)");
+            if (capacityString == null && !capacityDimensionsExist) {
+                throw new IllegalArgumentException("capacity of shipment is not set. use 'capacity-dimensions'");
+            }
+            if (capacityString != null && capacityDimensionsExist) {
+                throw new IllegalArgumentException("either use capacity or capacity-dimension, not both. prefer the use of 'capacity-dimensions' over 'capacity'.");
+            }
+
+            Shipment.Builder builder;
+            if (capacityString != null) {
+                builder = Shipment.Builder.newInstance(id).addSizeDimension(0, Integer.parseInt(capacityString));
+            } else {
+                builder = Shipment.Builder.newInstance(id);
+                List<HierarchicalConfiguration> dimensionConfigs = shipmentConfig.configurationsAt("capacity-dimensions.dimension");
+                for (HierarchicalConfiguration dimension : dimensionConfigs) {
+                    Integer index = dimension.getInt("[@index]");
+                    Integer value = dimension.getInt("");
+                    builder.addSizeDimension(index, value);
+                }
+            }
+
+            //name
+            String name = shipmentConfig.getString("name");
+            if (name != null) builder.setName(name);
+
+            //pickup location
+            //pickup-locationId
+            Location.Builder pickupLocationBuilder = Location.Builder.newInstance();
+            String pickupLocationId = shipmentConfig.getString("pickup.locationId");
+            if (pickupLocationId == null) pickupLocationId = shipmentConfig.getString("pickup.location.id");
+            if (pickupLocationId != null) {
+                pickupLocationBuilder.setId(pickupLocationId);
+            }
+
+            //pickup-coord
+            Coordinate pickupCoord = getCoord(shipmentConfig, "pickup.");
+            if (pickupCoord == null) pickupCoord = getCoord(shipmentConfig, "pickup.location.");
+            if (pickupCoord != null) {
+                pickupLocationBuilder.setCoordinate(pickupCoord);
+            }
+
+            //pickup.location.index
+            String pickupLocationIndex = shipmentConfig.getString("pickup.location.index");
+            if (pickupLocationIndex != null) pickupLocationBuilder.setIndex(Integer.parseInt(pickupLocationIndex));
+            builder.setPickupLocation(pickupLocationBuilder.build());
+
+            //pickup-serviceTime
+            String pickupServiceTime = shipmentConfig.getString("pickup.duration");
+            if (pickupServiceTime != null) builder.setPickupServiceTime(Double.parseDouble(pickupServiceTime));
+
+            //pickup-tw
+            List<HierarchicalConfiguration> pickupTWConfigs = shipmentConfig.configurationsAt("pickup.timeWindows.timeWindow");
+            if (!pickupTWConfigs.isEmpty()) {
+                for (HierarchicalConfiguration pu_twConfig : pickupTWConfigs) {
+                    builder.addPickupTimeWindow(TimeWindow.newInstance(pu_twConfig.getDouble("start"), pu_twConfig.getDouble("end")));
+                }
+            }
+
+            //delivery location
+            //delivery-locationId
+            Location.Builder deliveryLocationBuilder = Location.Builder.newInstance();
+            String deliveryLocationId = shipmentConfig.getString("delivery.locationId");
+            if (deliveryLocationId == null) deliveryLocationId = shipmentConfig.getString("delivery.location.id");
+            if (deliveryLocationId != null) {
+                deliveryLocationBuilder.setId(deliveryLocationId);
+//				builder.setDeliveryLocationId(deliveryLocationId);
+            }
+
+            //delivery-coord
+            Coordinate deliveryCoord = getCoord(shipmentConfig, "delivery.");
+            if (deliveryCoord == null) deliveryCoord = getCoord(shipmentConfig, "delivery.location.");
+            if (deliveryCoord != null) {
+                deliveryLocationBuilder.setCoordinate(deliveryCoord);
+            }
+
+            String deliveryLocationIndex = shipmentConfig.getString("delivery.location.index");
+            if (deliveryLocationIndex != null)
+                deliveryLocationBuilder.setIndex(Integer.parseInt(deliveryLocationIndex));
+            builder.setDeliveryLocation(deliveryLocationBuilder.build());
+
+            //delivery-serviceTime
+            String deliveryServiceTime = shipmentConfig.getString("delivery.duration");
+            if (deliveryServiceTime != null) builder.setDeliveryServiceTime(Double.parseDouble(deliveryServiceTime));
+
+            //delivery-tw
+            List<HierarchicalConfiguration> deliveryTWConfigs = shipmentConfig.configurationsAt("delivery.timeWindows.timeWindow");
+            if (!deliveryTWConfigs.isEmpty()) {
+                for (HierarchicalConfiguration dl_twConfig : deliveryTWConfigs) {
+                    builder.addDeliveryTimeWindow(TimeWindow.newInstance(dl_twConfig.getDouble("start"), dl_twConfig.getDouble("end")));
+                }
+            }
+
+            //read skills
+            String skillString = shipmentConfig.getString("requiredSkills");
+            if (skillString != null) {
+                String cleaned = skillString.replaceAll("\\s", "");
+                String[] skillTokens = cleaned.split("[,;]");
+                for (String skill : skillTokens) builder.addRequiredSkill(skill.toLowerCase());
+            }
+
+            //build shipment
+            Shipment shipment = builder.build();
+//			vrpBuilder.addJob(shipment);
+            shipmentMap.put(shipment.getId(), shipment);
+        }
+    }
+
+    private static Coordinate getCoord(HierarchicalConfiguration serviceConfig, String prefix) {
+        Coordinate pickupCoord = null;
+        if (serviceConfig.getString(prefix + "coord[@x]") != null && serviceConfig.getString(prefix + "coord[@y]") != null) {
+            double x = Double.parseDouble(serviceConfig.getString(prefix + "coord[@x]"));
+            double y = Double.parseDouble(serviceConfig.getString(prefix + "coord[@y]"));
+            pickupCoord = Coordinate.newInstance(x, y);
+        }
+        return pickupCoord;
+    }
+
+    private void readServices(XMLConfiguration vrpProblem) {
+        List<HierarchicalConfiguration> serviceConfigs = vrpProblem.configurationsAt("services.service");
+        for (HierarchicalConfiguration serviceConfig : serviceConfigs) {
+            String id = serviceConfig.getString("[@id]");
+            if (id == null) throw new IllegalArgumentException("service[@id] is missing.");
+            String type = serviceConfig.getString("[@type]");
+            if (type == null) type = "service";
+
+            String capacityString = serviceConfig.getString("capacity-demand");
+            boolean capacityDimensionsExist = serviceConfig.containsKey("capacity-dimensions.dimension(0)");
+            if (capacityString == null && !capacityDimensionsExist) {
+                throw new IllegalArgumentException("capacity of service is not set. use 'capacity-dimensions'");
+            }
+            if (capacityString != null && capacityDimensionsExist) {
+                throw new IllegalArgumentException("either use capacity or capacity-dimension, not both. prefer the use of 'capacity-dimensions' over 'capacity'.");
+            }
+
+            Service.Builder builder;
+            if (capacityString != null) {
+                builder = serviceBuilderFactory.createBuilder(type, id, Integer.parseInt(capacityString));
+            } else {
+                builder = serviceBuilderFactory.createBuilder(type, id, null);
+                List<HierarchicalConfiguration> dimensionConfigs = serviceConfig.configurationsAt("capacity-dimensions.dimension");
+                for (HierarchicalConfiguration dimension : dimensionConfigs) {
+                    Integer index = dimension.getInt("[@index]");
+                    Integer value = dimension.getInt("");
+                    builder.addSizeDimension(index, value);
+                }
+            }
+
+            //name
+            String name = serviceConfig.getString("name");
+            if (name != null) builder.setName(name);
+
+            //location
+            Location.Builder locationBuilder = Location.Builder.newInstance();
+            String serviceLocationId = serviceConfig.getString("locationId");
+            if (serviceLocationId == null) {
+                serviceLocationId = serviceConfig.getString("location.id");
+            }
+            if (serviceLocationId != null) locationBuilder.setId(serviceLocationId);
+
+            Coordinate serviceCoord = getCoord(serviceConfig, "");
+            if (serviceCoord == null) serviceCoord = getCoord(serviceConfig, "location.");
+            if (serviceCoord != null) {
+                locationBuilder.setCoordinate(serviceCoord);
+            }
+
+            String locationIndex = serviceConfig.getString("location.index");
+            if (locationIndex != null) locationBuilder.setIndex(Integer.parseInt(locationIndex));
+            builder.setLocation(locationBuilder.build());
+
+            if (serviceConfig.containsKey("duration")) {
+                builder.setServiceTime(serviceConfig.getDouble("duration"));
+            }
+            List<HierarchicalConfiguration> deliveryTWConfigs = serviceConfig.configurationsAt("timeWindows.timeWindow");
+            if (!deliveryTWConfigs.isEmpty()) {
+                for (HierarchicalConfiguration twConfig : deliveryTWConfigs) {
+                    builder.addTimeWindow(TimeWindow.newInstance(twConfig.getDouble("start"), twConfig.getDouble("end")));
+                }
+            }
+
+            //read skills
+            String skillString = serviceConfig.getString("requiredSkills");
+            if (skillString != null) {
+                String cleaned = skillString.replaceAll("\\s", "");
+                String[] skillTokens = cleaned.split("[,;]");
+                for (String skill : skillTokens) builder.addRequiredSkill(skill.toLowerCase());
+            }
+
+            //build service
+            Service service = builder.build();
+            serviceMap.put(service.getId(), service);
+//			vrpBuilder.addJob(service);
+
+        }
+    }
+
+    private void readVehiclesAndTheirTypes(XMLConfiguration vrpProblem) {
+
+        //read vehicle-types
+        Map<String, VehicleType> types = new HashMap<String, VehicleType>();
+        List<HierarchicalConfiguration> typeConfigs = vrpProblem.configurationsAt("vehicleTypes.type");
+        for (HierarchicalConfiguration typeConfig : typeConfigs) {
+            String typeId = typeConfig.getString("id");
+            if (typeId == null) throw new IllegalArgumentException("typeId is missing.");
+
+            String capacityString = typeConfig.getString("capacity");
+            boolean capacityDimensionsExist = typeConfig.containsKey("capacity-dimensions.dimension(0)");
+            if (capacityString == null && !capacityDimensionsExist) {
+                throw new IllegalArgumentException("capacity of type is not set. use 'capacity-dimensions'");
+            }
+            if (capacityString != null && capacityDimensionsExist) {
+                throw new IllegalArgumentException("either use capacity or capacity-dimension, not both. prefer the use of 'capacity-dimensions' over 'capacity'.");
+            }
+
+            VehicleTypeImpl.Builder typeBuilder;
+            if (capacityString != null) {
+                typeBuilder = VehicleTypeImpl.Builder.newInstance(typeId).addCapacityDimension(0, Integer.parseInt(capacityString));
+            } else {
+                typeBuilder = VehicleTypeImpl.Builder.newInstance(typeId);
+                List<HierarchicalConfiguration> dimensionConfigs = typeConfig.configurationsAt("capacity-dimensions.dimension");
+                for (HierarchicalConfiguration dimension : dimensionConfigs) {
+                    Integer index = dimension.getInt("[@index]");
+                    Integer value = dimension.getInt("");
+                    typeBuilder.addCapacityDimension(index, value);
+                }
+            }
+
+            Double fix = typeConfig.getDouble("costs.fixed");
+            Double timeC = typeConfig.getDouble("costs.time");
+            Double distC = typeConfig.getDouble("costs.distance");
+            if(typeConfig.containsKey("costs.service")){
+                Double serviceC = typeConfig.getDouble("costs.service");
+                if (serviceC != null) typeBuilder.setCostPerServiceTime(serviceC);
+            }
+
+            if(typeConfig.containsKey("costs.wait")){
+                Double waitC = typeConfig.getDouble("costs.wait");
+                if (waitC != null) typeBuilder.setCostPerWaitingTime(waitC);
+            }
+
+            if (fix != null) typeBuilder.setFixedCost(fix);
+            if (timeC != null) typeBuilder.setCostPerTransportTime(timeC);
+            if (distC != null) typeBuilder.setCostPerDistance(distC);
+            VehicleType type = typeBuilder.build();
+            String id = type.getTypeId();
+            types.put(id, type);
+        }
+
+        //read vehicles
+        List<HierarchicalConfiguration> vehicleConfigs = vrpProblem.configurationsAt("vehicles.vehicle");
+        boolean doNotWarnAgain = false;
+        for (HierarchicalConfiguration vehicleConfig : vehicleConfigs) {
+            String vehicleId = vehicleConfig.getString("id");
+            if (vehicleId == null) throw new IllegalArgumentException("vehicleId is missing.");
+            Builder builder = VehicleImpl.Builder.newInstance(vehicleId);
+            String typeId = vehicleConfig.getString("typeId");
+            if (typeId == null) throw new IllegalArgumentException("typeId is missing.");
+            String vType = vehicleConfig.getString("[@type]");
+            if (vType != null) {
+                if (vType.equals("penalty")) {
+                    typeId += "_penalty";
+                }
+            }
+            VehicleType type = types.get(typeId);
+            if (type == null) throw new IllegalArgumentException("vehicleType with typeId " + typeId + " is missing.");
+            builder.setType(type);
+
+            //read startlocation
+            Location.Builder startLocationBuilder = Location.Builder.newInstance();
+            String locationId = vehicleConfig.getString("location.id");
+            if (locationId == null) {
+                locationId = vehicleConfig.getString("startLocation.id");
+            }
+            startLocationBuilder.setId(locationId);
+            String coordX = vehicleConfig.getString("location.coord[@x]");
+            String coordY = vehicleConfig.getString("location.coord[@y]");
+            if (coordX == null || coordY == null) {
+                coordX = vehicleConfig.getString("startLocation.coord[@x]");
+                coordY = vehicleConfig.getString("startLocation.coord[@y]");
+            }
+            if (coordX == null || coordY == null) {
+                if (!doNotWarnAgain) {
+                    logger.debug("location.coord is missing. will not warn you again.");
+                    doNotWarnAgain = true;
+                }
+            } else {
+                Coordinate coordinate = Coordinate.newInstance(Double.parseDouble(coordX), Double.parseDouble(coordY));
+                startLocationBuilder.setCoordinate(coordinate);
+            }
+            String index = vehicleConfig.getString("startLocation.index");
+            if (index == null) index = vehicleConfig.getString("location.index");
+            if (index != null) {
+                startLocationBuilder.setIndex(Integer.parseInt(index));
+            }
+            builder.setStartLocation(startLocationBuilder.build());
+
+            //read endlocation
+            Location.Builder endLocationBuilder = Location.Builder.newInstance();
+            boolean hasEndLocation = false;
+            String endLocationId = vehicleConfig.getString("endLocation.id");
+            if (endLocationId != null) {
+                hasEndLocation = true;
+                endLocationBuilder.setId(endLocationId);
+            }
+            String endCoordX = vehicleConfig.getString("endLocation.coord[@x]");
+            String endCoordY = vehicleConfig.getString("endLocation.coord[@y]");
+            if (endCoordX == null || endCoordY == null) {
+                if (!doNotWarnAgain) {
+                    logger.debug("endLocation.coord is missing. will not warn you again.");
+                    doNotWarnAgain = true;
+                }
+            } else {
+                Coordinate coordinate = Coordinate.newInstance(Double.parseDouble(endCoordX), Double.parseDouble(endCoordY));
+                hasEndLocation = true;
+                endLocationBuilder.setCoordinate(coordinate);
+            }
+            String endLocationIndex = vehicleConfig.getString("endLocation.index");
+            if (endLocationIndex != null) {
+                hasEndLocation = true;
+                endLocationBuilder.setIndex(Integer.parseInt(endLocationIndex));
+            }
+            if (hasEndLocation) builder.setEndLocation(endLocationBuilder.build());
+
+            //read timeSchedule
+            String start = vehicleConfig.getString("timeSchedule.start");
+            String end = vehicleConfig.getString("timeSchedule.end");
+            if (start != null) builder.setEarliestStart(Double.parseDouble(start));
+            if (end != null) builder.setLatestArrival(Double.parseDouble(end));
+
+            //read return2depot
+            String returnToDepot = vehicleConfig.getString("returnToDepot");
+            if (returnToDepot != null) {
+                builder.setReturnToDepot(vehicleConfig.getBoolean("returnToDepot"));
+            }
+
+            //read skills
+            String skillString = vehicleConfig.getString("skills");
+            if (skillString != null) {
+                String cleaned = skillString.replaceAll("\\s", "");
+                String[] skillTokens = cleaned.split("[,;]");
+                for (String skill : skillTokens) builder.addSkill(skill.toLowerCase());
+            }
+
+            // read break
+            List<HierarchicalConfiguration> breakTWConfigs = vehicleConfig.configurationsAt("breaks.timeWindows.timeWindow");
+            if (!breakTWConfigs.isEmpty()) {
+                String breakDurationString = vehicleConfig.getString("breaks.duration");
+                Break.Builder current_break = Break.Builder.newInstance(vehicleId);
+                current_break.setServiceTime(Double.parseDouble(breakDurationString));
+                for (HierarchicalConfiguration twConfig : breakTWConfigs) {
+                	current_break.addTimeWindow(TimeWindow.newInstance(twConfig.getDouble("start"), twConfig.getDouble("end")));
+                }
+                builder.setBreak(current_break.build());
+            }
+
+
+            //build vehicle
+            VehicleImpl vehicle = builder.build();
+            vrpBuilder.addVehicle(vehicle);
+            vehicleMap.put(vehicleId, vehicle);
+        }
+
+    }
+
+
+}

jsprit-io/src/main/java/com/graphhopper/jsprit/io/problem/VrpXMLWriter.java

@@ -0,0 +1,435 @@
+/*******************************************************************************
+ * 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/>.
+ ******************************************************************************/
+package com.graphhopper.jsprit.io.problem;
+
+import com.graphhopper.jsprit.core.problem.Location;
+import com.graphhopper.jsprit.core.problem.Skills;
+import com.graphhopper.jsprit.core.problem.VehicleRoutingProblem;
+import com.graphhopper.jsprit.core.problem.job.Break;
+import com.graphhopper.jsprit.core.problem.job.Job;
+import com.graphhopper.jsprit.core.problem.job.Service;
+import com.graphhopper.jsprit.core.problem.job.Shipment;
+import com.graphhopper.jsprit.core.problem.solution.VehicleRoutingProblemSolution;
+import com.graphhopper.jsprit.core.problem.solution.route.VehicleRoute;
+import com.graphhopper.jsprit.core.problem.solution.route.activity.TimeWindow;
+import com.graphhopper.jsprit.core.problem.solution.route.activity.TourActivity;
+import com.graphhopper.jsprit.core.problem.vehicle.Vehicle;
+import com.graphhopper.jsprit.core.problem.vehicle.VehicleType;
+import com.graphhopper.jsprit.core.util.Solutions;
+import com.graphhopper.jsprit.core.util.VehicleIndexComparator;
+
+import org.apache.commons.configuration.ConfigurationException;
+import org.apache.commons.configuration.XMLConfiguration;
+import org.apache.xml.serialize.OutputFormat;
+import org.apache.xml.serialize.XMLSerializer;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.w3c.dom.Document;
+import org.w3c.dom.Element;
+
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.Writer;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+
+
+public class VrpXMLWriter {
+
+    static class XMLConf extends XMLConfiguration {
+
+
+        /**
+         *
+         */
+        private static final long serialVersionUID = 1L;
+
+        public Document createDoc() throws ConfigurationException {
+            return createDocument();
+        }
+    }
+
+    private Logger log = LoggerFactory.getLogger(VrpXMLWriter.class);
+
+    private VehicleRoutingProblem vrp;
+
+    private Collection<VehicleRoutingProblemSolution> solutions;
+
+    private boolean onlyBestSolution = false;
+
+    public VrpXMLWriter(VehicleRoutingProblem vrp, Collection<VehicleRoutingProblemSolution> solutions, boolean onlyBestSolution) {
+        this.vrp = vrp;
+        this.solutions = new ArrayList<VehicleRoutingProblemSolution>(solutions);
+        this.onlyBestSolution = onlyBestSolution;
+    }
+
+    public VrpXMLWriter(VehicleRoutingProblem vrp, Collection<VehicleRoutingProblemSolution> solutions) {
+        this.vrp = vrp;
+        this.solutions = solutions;
+    }
+
+    public VrpXMLWriter(VehicleRoutingProblem vrp) {
+        this.vrp = vrp;
+        this.solutions = null;
+    }
+
+    private static Logger logger = LoggerFactory.getLogger(VrpXMLWriter.class);
+
+    public void write(String filename) {
+        if (!filename.endsWith(".xml")) filename += ".xml";
+        log.info("write vrp: " + filename);
+        XMLConf xmlConfig = new XMLConf();
+        xmlConfig.setFileName(filename);
+        xmlConfig.setRootElementName("problem");
+        xmlConfig.setAttributeSplittingDisabled(true);
+        xmlConfig.setDelimiterParsingDisabled(true);
+
+        writeProblemType(xmlConfig);
+        writeVehiclesAndTheirTypes(xmlConfig);
+
+        //might be sorted?
+        List<Job> jobs = new ArrayList<Job>();
+        jobs.addAll(vrp.getJobs().values());
+        for (VehicleRoute r : vrp.getInitialVehicleRoutes()) {
+            jobs.addAll(r.getTourActivities().getJobs());
+        }
+
+        writeServices(xmlConfig, jobs);
+        writeShipments(xmlConfig, jobs);
+
+        writeInitialRoutes(xmlConfig);
+        if(onlyBestSolution && solutions != null) {
+            VehicleRoutingProblemSolution solution = Solutions.bestOf(solutions);
+            solutions.clear();
+            solutions.add(solution);
+        }
+
+        writeSolutions(xmlConfig);
+
+
+        OutputFormat format = new OutputFormat();
+        format.setIndenting(true);
+        format.setIndent(5);
+
+        try {
+            Document document = xmlConfig.createDoc();
+
+            Element element = document.getDocumentElement();
+            element.setAttribute("xmlns", "http://www.w3schools.com");
+            element.setAttribute("xmlns:xsi", "http://www.w3.org/2001/XMLSchema-instance");
+            element.setAttribute("xsi:schemaLocation", "http://www.w3schools.com vrp_xml_schema.xsd");
+
+        } catch (ConfigurationException e) {
+            throw new RuntimeException(e);
+        }
+
+        try {
+            Writer out = new FileWriter(filename);
+            XMLSerializer serializer = new XMLSerializer(out, format);
+            serializer.serialize(xmlConfig.getDocument());
+            out.close();
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+
+
+    }
+
+    private void writeInitialRoutes(XMLConf xmlConfig) {
+        if (vrp.getInitialVehicleRoutes().isEmpty()) return;
+        String path = "initialRoutes.route";
+        int routeCounter = 0;
+        for (VehicleRoute route : vrp.getInitialVehicleRoutes()) {
+            xmlConfig.setProperty(path + "(" + routeCounter + ").driverId", route.getDriver().getId());
+            xmlConfig.setProperty(path + "(" + routeCounter + ").vehicleId", route.getVehicle().getId());
+            xmlConfig.setProperty(path + "(" + routeCounter + ").start", route.getStart().getEndTime());
+            int actCounter = 0;
+            for (TourActivity act : route.getTourActivities().getActivities()) {
+                xmlConfig.setProperty(path + "(" + routeCounter + ").act(" + actCounter + ")[@type]", act.getName());
+                if (act instanceof TourActivity.JobActivity) {
+                    Job job = ((TourActivity.JobActivity) act).getJob();
+                    if (job instanceof Service) {
+                        xmlConfig.setProperty(path + "(" + routeCounter + ").act(" + actCounter + ").serviceId", job.getId());
+                    } else if (job instanceof Shipment) {
+                        xmlConfig.setProperty(path + "(" + routeCounter + ").act(" + actCounter + ").shipmentId", job.getId());
+                    } else if (job instanceof Break) {
+                    	xmlConfig.setProperty(path + "(" + routeCounter + ").act(" + actCounter + ").breakId", job.getId());
+                    } else {
+                        throw new IllegalStateException("cannot write solution correctly since job-type is not know. make sure you use either service or shipment, or another writer");
+                    }
+                }
+                xmlConfig.setProperty(path + "(" + routeCounter + ").act(" + actCounter + ").arrTime", act.getArrTime());
+                xmlConfig.setProperty(path + "(" + routeCounter + ").act(" + actCounter + ").endTime", act.getEndTime());
+                actCounter++;
+            }
+            xmlConfig.setProperty(path + "(" + routeCounter + ").end", route.getEnd().getArrTime());
+            routeCounter++;
+        }
+
+    }
+
+    private void writeSolutions(XMLConf xmlConfig) {
+        if (solutions == null) return;
+        String solutionPath = "solutions.solution";
+        int counter = 0;
+        for (VehicleRoutingProblemSolution solution : solutions) {
+            xmlConfig.setProperty(solutionPath + "(" + counter + ").cost", solution.getCost());
+            int routeCounter = 0;
+            List<VehicleRoute> list = new ArrayList<VehicleRoute>(solution.getRoutes());
+            Collections.sort(list , new VehicleIndexComparator());
+            for (VehicleRoute route : list) {
+//				xmlConfig.setProperty(solutionPath + "(" + counter + ").routes.route(" + routeCounter + ").cost", route.getCost());
+                xmlConfig.setProperty(solutionPath + "(" + counter + ").routes.route(" + routeCounter + ").driverId", route.getDriver().getId());
+                xmlConfig.setProperty(solutionPath + "(" + counter + ").routes.route(" + routeCounter + ").vehicleId", route.getVehicle().getId());
+                xmlConfig.setProperty(solutionPath + "(" + counter + ").routes.route(" + routeCounter + ").start", route.getStart().getEndTime());
+                int actCounter = 0;
+                for (TourActivity act : route.getTourActivities().getActivities()) {
+                    xmlConfig.setProperty(solutionPath + "(" + counter + ").routes.route(" + routeCounter + ").act(" + actCounter + ")[@type]", act.getName());
+                    if (act instanceof TourActivity.JobActivity) {
+                        Job job = ((TourActivity.JobActivity) act).getJob();
+                        if (job instanceof Service) {
+                            xmlConfig.setProperty(solutionPath + "(" + counter + ").routes.route(" + routeCounter + ").act(" + actCounter + ").serviceId", job.getId());
+                        } else if (job instanceof Shipment) {
+                            xmlConfig.setProperty(solutionPath + "(" + counter + ").routes.route(" + routeCounter + ").act(" + actCounter + ").shipmentId", job.getId());
+                        } else if (job instanceof Break) {
+                        	xmlConfig.setProperty(solutionPath + "(" + counter + ").routes.route(" + routeCounter + ").act(" + actCounter + ").breakId", job.getId());
+                        } else {
+                            throw new IllegalStateException("cannot write solution correctly since job-type is not know. make sure you use either service or shipment, or another writer");
+                        }
+                    }
+                    xmlConfig.setProperty(solutionPath + "(" + counter + ").routes.route(" + routeCounter + ").act(" + actCounter + ").arrTime", act.getArrTime());
+                    xmlConfig.setProperty(solutionPath + "(" + counter + ").routes.route(" + routeCounter + ").act(" + actCounter + ").endTime", act.getEndTime());
+                    actCounter++;
+                }
+                xmlConfig.setProperty(solutionPath + "(" + counter + ").routes.route(" + routeCounter + ").end", route.getEnd().getArrTime());
+                routeCounter++;
+            }
+            int unassignedJobCounter = 0;
+            for (Job unassignedJob : solution.getUnassignedJobs()) {
+                xmlConfig.setProperty(solutionPath + "(" + counter + ").unassignedJobs.job(" + unassignedJobCounter + ")[@id]", unassignedJob.getId());
+                unassignedJobCounter++;
+            }
+            counter++;
+        }
+    }
+
+    private void writeServices(XMLConf xmlConfig, List<Job> jobs) {
+        String shipmentPathString = "services.service";
+        int counter = 0;
+        for (Job j : jobs) {
+            if (!(j instanceof Service)) continue;
+            Service service = (Service) j;
+            xmlConfig.setProperty(shipmentPathString + "(" + counter + ")[@id]", service.getId());
+            xmlConfig.setProperty(shipmentPathString + "(" + counter + ")[@type]", service.getType());
+            if (service.getLocation().getId() != null)
+                xmlConfig.setProperty(shipmentPathString + "(" + counter + ").location.id", service.getLocation().getId());
+            if (service.getLocation().getCoordinate() != null) {
+                xmlConfig.setProperty(shipmentPathString + "(" + counter + ").location.coord[@x]", service.getLocation().getCoordinate().getX());
+                xmlConfig.setProperty(shipmentPathString + "(" + counter + ").location.coord[@y]", service.getLocation().getCoordinate().getY());
+            }
+            if (service.getLocation().getIndex() != Location.NO_INDEX) {
+                xmlConfig.setProperty(shipmentPathString + "(" + counter + ").location.index", service.getLocation().getIndex());
+            }
+            for (int i = 0; i < service.getSize().getNuOfDimensions(); i++) {
+                xmlConfig.setProperty(shipmentPathString + "(" + counter + ").capacity-dimensions.dimension(" + i + ")[@index]", i);
+                xmlConfig.setProperty(shipmentPathString + "(" + counter + ").capacity-dimensions.dimension(" + i + ")", service.getSize().get(i));
+            }
+
+            Collection<TimeWindow> tws = service.getTimeWindows();
+            int index = 0;
+            xmlConfig.setProperty(shipmentPathString + "(" + counter + ").duration", service.getServiceDuration());
+            for(TimeWindow tw : tws) {
+	            xmlConfig.setProperty(shipmentPathString + "(" + counter + ").timeWindows.timeWindow(" + index + ").start", tw.getStart());
+	            xmlConfig.setProperty(shipmentPathString + "(" + counter + ").timeWindows.timeWindow(" + index + ").end", tw.getEnd());
+	            ++index;
+            }
+
+            //skills
+            String skillString = getSkillString(service);
+            xmlConfig.setProperty(shipmentPathString + "(" + counter + ").requiredSkills", skillString);
+
+            //name
+            if (service.getName() != null) {
+                if (!service.getName().equals("no-name")) {
+                    xmlConfig.setProperty(shipmentPathString + "(" + counter + ").name", service.getName());
+                }
+            }
+            counter++;
+        }
+    }
+
+    private void writeShipments(XMLConf xmlConfig, List<Job> jobs) {
+        String shipmentPathString = "shipments.shipment";
+        int counter = 0;
+        for (Job j : jobs) {
+            if (!(j instanceof Shipment)) continue;
+            Shipment shipment = (Shipment) j;
+            xmlConfig.setProperty(shipmentPathString + "(" + counter + ")[@id]", shipment.getId());
+//			xmlConfig.setProperty(shipmentPathString + "("+counter+")[@type]", service.getType());
+            if (shipment.getPickupLocation().getId() != null)
+                xmlConfig.setProperty(shipmentPathString + "(" + counter + ").pickup.location.id", shipment.getPickupLocation().getId());
+            if (shipment.getPickupLocation().getCoordinate() != null) {
+                xmlConfig.setProperty(shipmentPathString + "(" + counter + ").pickup.location.coord[@x]", shipment.getPickupLocation().getCoordinate().getX());
+                xmlConfig.setProperty(shipmentPathString + "(" + counter + ").pickup.location.coord[@y]", shipment.getPickupLocation().getCoordinate().getY());
+            }
+            if (shipment.getPickupLocation().getIndex() != Location.NO_INDEX) {
+                xmlConfig.setProperty(shipmentPathString + "(" + counter + ").pickup.location.index", shipment.getPickupLocation().getIndex());
+            }
+
+            Collection<TimeWindow> pu_tws = shipment.getPickupTimeWindows();
+            int index = 0;
+            xmlConfig.setProperty(shipmentPathString + "(" + counter + ").pickup.duration", shipment.getPickupServiceTime());
+            for(TimeWindow tw : pu_tws) {
+	            xmlConfig.setProperty(shipmentPathString + "(" + counter + ").pickup.timeWindows.timeWindow(" + index + ").start", tw.getStart());
+	            xmlConfig.setProperty(shipmentPathString + "(" + counter + ").pickup.timeWindows.timeWindow(" + index + ").end", tw.getEnd());
+	            ++index;
+	        }
+
+            if (shipment.getDeliveryLocation().getId() != null)
+                xmlConfig.setProperty(shipmentPathString + "(" + counter + ").delivery.location.id", shipment.getDeliveryLocation().getId());
+            if (shipment.getDeliveryLocation().getCoordinate() != null) {
+                xmlConfig.setProperty(shipmentPathString + "(" + counter + ").delivery.location.coord[@x]", shipment.getDeliveryLocation().getCoordinate().getX());
+                xmlConfig.setProperty(shipmentPathString + "(" + counter + ").delivery.location.coord[@y]", shipment.getDeliveryLocation().getCoordinate().getY());
+            }
+            if (shipment.getDeliveryLocation().getIndex() != Location.NO_INDEX) {
+                xmlConfig.setProperty(shipmentPathString + "(" + counter + ").delivery.location.index", shipment.getDeliveryLocation().getIndex());
+            }
+
+            Collection<TimeWindow> del_tws = shipment.getDeliveryTimeWindows();
+        	xmlConfig.setProperty(shipmentPathString + "(" + counter + ").delivery.duration", shipment.getDeliveryServiceTime());
+        	index = 0;
+            for(TimeWindow tw : del_tws) {
+            	xmlConfig.setProperty(shipmentPathString + "(" + counter + ").delivery.timeWindows.timeWindow(" + index + ").start", tw.getStart());
+            	xmlConfig.setProperty(shipmentPathString + "(" + counter + ").delivery.timeWindows.timeWindow(" + index + ").end", tw.getEnd());
+            	++index;
+            }
+
+            for (int i = 0; i < shipment.getSize().getNuOfDimensions(); i++) {
+                xmlConfig.setProperty(shipmentPathString + "(" + counter + ").capacity-dimensions.dimension(" + i + ")[@index]", i);
+                xmlConfig.setProperty(shipmentPathString + "(" + counter + ").capacity-dimensions.dimension(" + i + ")", shipment.getSize().get(i));
+            }
+
+            //skills
+            String skillString = getSkillString(shipment);
+            xmlConfig.setProperty(shipmentPathString + "(" + counter + ").requiredSkills", skillString);
+
+            //name
+            if (shipment.getName() != null) {
+                if (!shipment.getName().equals("no-name")) {
+                    xmlConfig.setProperty(shipmentPathString + "(" + counter + ").name", shipment.getName());
+                }
+            }
+            counter++;
+        }
+    }
+
+    private void writeProblemType(XMLConfiguration xmlConfig) {
+        xmlConfig.setProperty("problemType.fleetSize", vrp.getFleetSize());
+    }
+
+    private void writeVehiclesAndTheirTypes(XMLConfiguration xmlConfig) {
+
+        //vehicles
+        String vehiclePathString = Schema.VEHICLES + "." + Schema.VEHICLE;
+        int counter = 0;
+        for (Vehicle vehicle : vrp.getVehicles()) {
+            xmlConfig.setProperty(vehiclePathString + "(" + counter + ").id", vehicle.getId());
+            xmlConfig.setProperty(vehiclePathString + "(" + counter + ").typeId", vehicle.getType().getTypeId());
+            xmlConfig.setProperty(vehiclePathString + "(" + counter + ").startLocation.id", vehicle.getStartLocation().getId());
+            if (vehicle.getStartLocation().getCoordinate() != null) {
+                xmlConfig.setProperty(vehiclePathString + "(" + counter + ").startLocation.coord[@x]", vehicle.getStartLocation().getCoordinate().getX());
+                xmlConfig.setProperty(vehiclePathString + "(" + counter + ").startLocation.coord[@y]", vehicle.getStartLocation().getCoordinate().getY());
+            }
+            if (vehicle.getStartLocation().getIndex() != Location.NO_INDEX) {
+                xmlConfig.setProperty(vehiclePathString + "(" + counter + ").startLocation.index", vehicle.getStartLocation().getIndex());
+            }
+
+            xmlConfig.setProperty(vehiclePathString + "(" + counter + ").endLocation.id", vehicle.getEndLocation().getId());
+            if (vehicle.getEndLocation().getCoordinate() != null) {
+                xmlConfig.setProperty(vehiclePathString + "(" + counter + ").endLocation.coord[@x]", vehicle.getEndLocation().getCoordinate().getX());
+                xmlConfig.setProperty(vehiclePathString + "(" + counter + ").endLocation.coord[@y]", vehicle.getEndLocation().getCoordinate().getY());
+            }
+            if (vehicle.getEndLocation().getIndex() != Location.NO_INDEX) {
+                xmlConfig.setProperty(vehiclePathString + "(" + counter + ").endLocation.index", vehicle.getEndLocation().getId());
+            }
+            xmlConfig.setProperty(vehiclePathString + "(" + counter + ").timeSchedule.start", vehicle.getEarliestDeparture());
+            xmlConfig.setProperty(vehiclePathString + "(" + counter + ").timeSchedule.end", vehicle.getLatestArrival());
+
+            if (vehicle.getBreak() != null) {
+                Collection<TimeWindow> tws = vehicle.getBreak().getTimeWindows();
+                int index = 0;
+	            xmlConfig.setProperty(vehiclePathString + "(" + counter + ").breaks.duration", vehicle.getBreak().getServiceDuration());
+                for(TimeWindow tw : tws) {
+		            xmlConfig.setProperty(vehiclePathString + "(" + counter + ").breaks.timeWindows.timeWindow(" + index + ").start", tw.getStart());
+		            xmlConfig.setProperty(vehiclePathString + "(" + counter + ").breaks.timeWindows.timeWindow(" + index + ").end", tw.getEnd());
+		            ++index;
+                }
+	        }
+            xmlConfig.setProperty(vehiclePathString + "(" + counter + ").returnToDepot", vehicle.isReturnToDepot());
+
+            //write skills
+            String skillString = getSkillString(vehicle);
+            xmlConfig.setProperty(vehiclePathString + "(" + counter + ").skills", skillString);
+
+            counter++;
+        }
+
+        //types
+        String typePathString = Schema.builder().append(Schema.TYPES).dot(Schema.TYPE).build();
+        int typeCounter = 0;
+        for (VehicleType type : vrp.getTypes()) {
+            xmlConfig.setProperty(typePathString + "(" + typeCounter + ").id", type.getTypeId());
+
+            for (int i = 0; i < type.getCapacityDimensions().getNuOfDimensions(); i++) {
+                xmlConfig.setProperty(typePathString + "(" + typeCounter + ").capacity-dimensions.dimension(" + i + ")[@index]", i);
+                xmlConfig.setProperty(typePathString + "(" + typeCounter + ").capacity-dimensions.dimension(" + i + ")", type.getCapacityDimensions().get(i));
+            }
+
+            xmlConfig.setProperty(typePathString + "(" + typeCounter + ").costs.fixed", type.getVehicleCostParams().fix);
+            xmlConfig.setProperty(typePathString + "(" + typeCounter + ").costs.distance", type.getVehicleCostParams().perDistanceUnit);
+            xmlConfig.setProperty(typePathString + "(" + typeCounter + ").costs.time", type.getVehicleCostParams().perTransportTimeUnit);
+            xmlConfig.setProperty(typePathString + "(" + typeCounter + ").costs.service", type.getVehicleCostParams().perServiceTimeUnit);
+            xmlConfig.setProperty(typePathString + "(" + typeCounter + ").costs.wait", type.getVehicleCostParams().perWaitingTimeUnit);
+            typeCounter++;
+        }
+
+
+    }
+
+    private String getSkillString(Vehicle vehicle) {
+        return createSkillString(vehicle.getSkills());
+    }
+
+    private String getSkillString(Job job) {
+        return createSkillString(job.getRequiredSkills());
+    }
+
+    private String createSkillString(Skills skills) {
+        if (skills.values().size() == 0) return null;
+        String skillString = null;
+        for (String skill : skills.values()) {
+            if (skillString == null) skillString = skill;
+            else skillString += ", " + skill;
+        }
+        return skillString;
+    }
+
+
+}
+

jsprit-io/src/main/resources/algorithm_schema.xsd

@@ -0,0 +1,276 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+  ~ 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/>.
+  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-->
+
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" targetNamespace="http://www.w3schools.com"
+           xmlns="http://www.w3schools.com" elementFormDefault="qualified">
+
+    <xs:element name="algorithm">
+        <xs:complexType>
+            <xs:sequence>
+                <xs:choice>
+                    <xs:element name="iterations" type="xs:integer" minOccurs="0" maxOccurs="1"/>
+                    <xs:element name="maxIterations" type="xs:integer" minOccurs="0" maxOccurs="1"/>
+                </xs:choice>
+
+                <xs:choice>
+                    <xs:element name="prematureBreak" type="prematureBreakType" minOccurs="0" maxOccurs="1"/>
+                    <xs:element name="terminationCriteria">
+                        <xs:complexType>
+                            <xs:sequence>
+                                <xs:element name="termination" type="prematureBreakType" minOccurs="0"
+                                            maxOccurs="unbounded"/>
+                            </xs:sequence>
+                        </xs:complexType>
+
+                    </xs:element>
+                </xs:choice>
+
+
+                <xs:element name="construction" minOccurs="0" maxOccurs="1">
+                    <xs:complexType>
+                        <xs:sequence>
+                            <xs:element name="insertion" type="insertionType" minOccurs="1" maxOccurs="1"/>
+                        </xs:sequence>
+                    </xs:complexType>
+                </xs:element>
+
+                <xs:element name="strategy">
+                    <xs:complexType>
+                        <xs:sequence>
+                            <xs:element name="memory" type="xs:integer" minOccurs="0" maxOccurs="1" default="1"/>
+                            <xs:element name="searchStrategies" minOccurs="1" maxOccurs="1">
+                                <xs:complexType>
+                                    <xs:sequence>
+                                        <xs:element name="searchStrategy" type="searchStrategyType" minOccurs="1"
+                                                    maxOccurs="unbounded"/>
+                                    </xs:sequence>
+                                </xs:complexType>
+                            </xs:element>
+                        </xs:sequence>
+                    </xs:complexType>
+                </xs:element>
+
+            </xs:sequence>
+        </xs:complexType>
+    </xs:element>
+
+    <xs:complexType name="searchStrategyType">
+        <xs:sequence>
+            <xs:element name="selector" type="selectorType"/>
+            <xs:element name="acceptor" type="acceptorType"/>
+            <xs:element name="modules" minOccurs="1" maxOccurs="1">
+                <xs:complexType>
+                    <xs:sequence>
+                        <xs:element name="module" type="moduleType" minOccurs="1" maxOccurs="unbounded"/>
+                    </xs:sequence>
+                </xs:complexType>
+            </xs:element>
+            <xs:element name="probability">
+                <xs:simpleType>
+                    <xs:restriction base="xs:double">
+                        <xs:minInclusive value="0.0"/>
+                        <xs:maxInclusive value="1.0"/>
+                    </xs:restriction>
+                </xs:simpleType>
+            </xs:element>
+        </xs:sequence>
+        <xs:attribute name="name" type="xs:string"/>
+    </xs:complexType>
+
+    <xs:complexType name="selectorType">
+        <xs:attribute name="name">
+            <xs:simpleType>
+                <xs:restriction base="xs:string">
+                    <xs:enumeration value="selectBest"/>
+                    <xs:enumeration value="selectRandomly"/>
+                </xs:restriction>
+            </xs:simpleType>
+        </xs:attribute>
+    </xs:complexType>
+
+    <xs:complexType name="acceptorType">
+        <xs:sequence>
+            <xs:element name="alpha" type="xs:double" minOccurs="0" maxOccurs="1"/>
+            <xs:choice>
+                <xs:element name="warmup" type="xs:int" minOccurs="0" maxOccurs="1"/>
+                <xs:element name="initialThreshold" type="xs:double" minOccurs="0" maxOccurs="1"/>
+            </xs:choice>
+
+        </xs:sequence>
+        <xs:attribute name="name">
+            <xs:simpleType>
+                <xs:restriction base="xs:string">
+                    <xs:enumeration value="acceptNewRemoveWorst"/>
+                    <xs:enumeration value="schrimpfAcceptance"/>
+                    <xs:enumeration value="experimentalSchrimpfAcceptance"/>
+                    <xs:enumeration value="acceptNewRemoveFirst"/>
+                    <xs:enumeration value="greedyAcceptance"/>
+                    <xs:enumeration value="greedyAcceptance_minVehFirst"/>
+                </xs:restriction>
+            </xs:simpleType>
+        </xs:attribute>
+
+    </xs:complexType>
+
+    <xs:complexType name="prematureBreakType">
+        <xs:choice>
+            <xs:group ref="pBreak_iteration_group"/>
+            <xs:group ref="pBreak_time_group"/>
+            <xs:group ref="pBreak_variationCoefficient_group"/>
+        </xs:choice>
+        <xs:attribute name="basedOn">
+            <xs:simpleType>
+                <xs:restriction base="xs:string">
+                    <xs:enumeration value="time"/>
+                    <xs:enumeration value="iterations"/>
+                    <xs:enumeration value="variationCoefficient"/>
+                </xs:restriction>
+            </xs:simpleType>
+        </xs:attribute>
+    </xs:complexType>
+
+    <xs:group name="pBreak_iteration_group">
+        <xs:sequence>
+            <xs:element name="iterations" type="xs:integer" minOccurs="1" maxOccurs="1"/>
+        </xs:sequence>
+    </xs:group>
+
+    <xs:group name="pBreak_time_group">
+        <xs:sequence>
+            <xs:element name="time" type="xs:long" minOccurs="1" maxOccurs="1"/>
+        </xs:sequence>
+    </xs:group>
+
+    <xs:group name="pBreak_variationCoefficient_group">
+        <xs:sequence>
+            <xs:element name="threshold" type="xs:double" minOccurs="1" maxOccurs="1"/>
+            <xs:element name="iterations" type="xs:integer" minOccurs="1" maxOccurs="1"/>
+        </xs:sequence>
+    </xs:group>
+
+    <xs:complexType name="moduleType">
+        <xs:choice>
+            <xs:group ref="ruin_and_recreate_group"/>
+            <xs:group ref="gendreau_group"/>
+        </xs:choice>
+        <xs:attribute name="name">
+            <xs:simpleType>
+                <xs:restriction base="xs:string">
+                    <xs:enumeration value="ruin_and_recreate"/>
+                    <xs:enumeration value="gendreau"/>
+                </xs:restriction>
+            </xs:simpleType>
+        </xs:attribute>
+    </xs:complexType>
+
+    <xs:group name="ruin_and_recreate_group">
+        <xs:sequence>
+            <xs:element name="ruin" type="ruinType"/>
+            <xs:element name="insertion" type="insertionType"/>
+        </xs:sequence>
+    </xs:group>
+
+    <xs:group name="gendreau_group">
+        <xs:sequence>
+            <xs:element name="iterations" type="xs:integer"/>
+            <xs:element name="share" type="xs:double"/>
+            <xs:element name="ruin" type="ruinType"/>
+            <xs:element name="insertion" type="insertionType"/>
+        </xs:sequence>
+    </xs:group>
+
+    <xs:complexType name="ruinType">
+        <xs:sequence>
+            <xs:element name="share" minOccurs="0" maxOccurs="1">
+                <xs:simpleType>
+                    <xs:restriction base="xs:double">
+                        <xs:minInclusive value="0.0"/>
+                        <xs:maxInclusive value="1.0"/>
+                    </xs:restriction>
+                </xs:simpleType>
+            </xs:element>
+            <xs:element name="distance" minOccurs="0" maxOccurs="1">
+                <xs:simpleType>
+                    <xs:restriction base="xs:string">
+                        <xs:enumeration value="euclidean"/>
+                    </xs:restriction>
+                </xs:simpleType>
+            </xs:element>
+        </xs:sequence>
+        <xs:attribute name="name" use="required">
+            <xs:simpleType>
+                <xs:restriction base="xs:string">
+                    <xs:enumeration value="randomRuin"/>
+                    <xs:enumeration value="radialRuin"/>
+                </xs:restriction>
+            </xs:simpleType>
+        </xs:attribute>
+        <xs:attribute name="id" type="xs:string"/>
+
+    </xs:complexType>
+
+
+    <xs:complexType name="insertionType">
+        <xs:all>
+            <xs:element name="level" minOccurs="0" maxOccurs="1">
+                <xs:complexType>
+                    <xs:simpleContent>
+                        <xs:extension base="xs:string">
+                            <xs:attribute name="forwardLooking" type="xs:string"/>
+                            <xs:attribute name="memory" type="xs:string"/>
+                        </xs:extension>
+                    </xs:simpleContent>
+                </xs:complexType>
+            </xs:element>
+            <xs:element name="considerFixedCosts" minOccurs="0" maxOccurs="1">
+                <xs:complexType>
+                    <xs:simpleContent>
+                        <xs:extension base="xs:string">
+                            <xs:attribute name="weight" type="xs:double"/>
+                        </xs:extension>
+                    </xs:simpleContent>
+
+                </xs:complexType>
+            </xs:element>
+            <xs:element name="allowVehicleSwitch" type="xs:boolean" minOccurs="0" maxOccurs="1"/>
+            <xs:element name="fastRegret" type="xs:boolean" minOccurs="0" maxOccurs="1"/>
+            <xs:element name="experimental" minOccurs="0" maxOccurs="1">
+                <xs:complexType>
+                    <xs:sequence>
+                        <xs:any minOccurs="0"/>
+                    </xs:sequence>
+                    <xs:attribute name="timeSlice" type="xs:string"/>
+                    <xs:attribute name="neighboringSlices" type="xs:string"/>
+                </xs:complexType>
+
+            </xs:element>
+
+        </xs:all>
+        <xs:attribute name="name" use="required">
+            <xs:simpleType>
+                <xs:restriction base="xs:string">
+                    <xs:enumeration value="bestInsertion"/>
+                    <xs:enumeration value="regretInsertion"/>
+                </xs:restriction>
+            </xs:simpleType>
+        </xs:attribute>
+        <xs:attribute name="id" type="xs:string"/>
+
+    </xs:complexType>
+
+</xs:schema>

jsprit-io/src/main/resources/config.xml

@@ -0,0 +1,67 @@
+<?xml version="1.0" ?>
+<config>
+
+    <controler>
+        <iterations>2000</iterations>
+    </controler>
+
+    <construction>
+        <insertion name="bestInsertion"/>
+    </construction>
+
+    <strategy>
+        <memory>3</memory>
+        <searchStrategies>
+
+            <searchStrategy id="randomRuinAndRecreate">
+                <selector name="selectBest"/>
+                <acceptor name="acceptNewRemoveWorst"/>
+                <!-- 			<acceptor id="1" name="schrimpfAcceptance">
+                                 <alpha>0.1</alpha>
+                                 <iterations>10</iterations>
+                             </acceptor> -->
+                <modules>
+                    <module name="randomRuin">
+                        <share>0.5</share>
+                    </module>
+                    <module name="bestInsertion"></module>
+                </modules>
+                <probability>0.5</probability>
+            </searchStrategy>
+
+            <searchStrategy id="radialRuinAndRecreate">
+                <selector id="1" name="selectBest"/>
+                <acceptor name="acceptNewRemoveWorst"/>
+                <!-- 			<acceptor id="1" name="schrimpfAcceptance">
+                                 <alpha>0.1</alpha>
+                                 <iterations>10</iterations>
+                             </acceptor> -->
+                <modules>
+                    <module name="radialRuin">
+                        <share>0.3</share>
+                        <distanceMeasure>euclid</distanceMeasure>
+                    </module>
+                    <module name="bestInsertion"></module>
+                </modules>
+                <probability>0.5</probability>
+            </searchStrategy>
+
+            <!--  			<searchStrategy id="gendreauPostOpt">  -->
+            <!-- 				<modules>  -->
+            <!-- 					<module name="gendreauPostOpt">  -->
+            <!-- 						<iterations>200</iterations>  -->
+            <!--  		 				<share>0.2</share>  -->
+            <!-- 					</module>  -->
+            <!-- 				</modules>  -->
+            <!--  				<probability>0.1</probability>  -->
+            <!--  			</searchStrategy> --> -->
+        </searchStrategies>
+
+        <before></before>
+
+        <after></after>
+
+    </strategy>
+
+
+</config>

jsprit-io/src/main/resources/greedySchrimpf.xml

@@ -0,0 +1,49 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<algorithm xmlns="http://www.w3schools.com"
+           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+           xsi:schemaLocation="http://www.w3schools.com algorithm_schema.xsd">
+
+    <iterations>2000</iterations>
+
+    <construction>
+        <insertion name="bestInsertion"/>
+    </construction>
+
+    <strategy>
+        <memory>1</memory>
+        <searchStrategies>
+            <searchStrategy name="randomRuinAndRecreate">
+                <selector name="selectBest"/>
+                <acceptor name="acceptNewRemoveWorst"/>
+                <modules>
+                    <module name="ruin_and_recreate">
+                        <ruin name="randomRuin">
+                            <share>0.5</share>
+                        </ruin>
+                        <insertion name="bestInsertion"/>
+                    </module>
+
+                </modules>
+                <probability>0.5</probability>
+            </searchStrategy>
+
+            <searchStrategy name="radialRuinAndRecreate">
+                <selector name="selectBest"/>
+                <acceptor name="acceptNewRemoveWorst"/>
+                <modules>
+                    <module name="ruin_and_recreate">
+                        <ruin name="radialRuin">
+                            <share>0.3</share>
+                        </ruin>
+                        <insertion name="bestInsertion"/>
+                    </module>
+
+                </modules>
+                <probability>0.5</probability>
+            </searchStrategy>
+
+        </searchStrategies>
+    </strategy>
+
+
+</algorithm>

jsprit-io/src/main/resources/randomWalk.xml

@@ -0,0 +1,47 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<algorithm xmlns="http://www.w3schools.com"
+           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+           xsi:schemaLocation="http://www.w3schools.com algorithm_schema.xsd">
+
+    <construction>
+        <insertion name="bestInsertion"/>
+    </construction>
+
+    <strategy>
+        <memory>1</memory>
+        <searchStrategies>
+            <searchStrategy name="randomRuinAndRecreate">
+                <selector name="selectBest"/>
+                <acceptor name="acceptNewRemoveFirst"/>
+                <modules>
+                    <module name="ruin_and_recreate">
+                        <ruin name="randomRuin">
+                            <share>0.5</share>
+                        </ruin>
+                        <insertion name="bestInsertion"/>
+                    </module>
+
+                </modules>
+                <probability>0.5</probability>
+            </searchStrategy>
+
+            <searchStrategy name="radialRuinAndRecreate">
+                <selector name="selectBest"/>
+                <acceptor name="acceptNewRemoveFirst"/>
+                <modules>
+                    <module name="ruin_and_recreate">
+                        <ruin name="radialRuin">
+                            <share>0.3</share>
+                        </ruin>
+                        <insertion name="bestInsertion"/>
+                    </module>
+
+                </modules>
+                <probability>0.5</probability>
+            </searchStrategy>
+
+        </searchStrategies>
+    </strategy>
+
+
+</algorithm>

jsprit-io/src/main/resources/schrimpf.xml

@@ -0,0 +1,52 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<algorithm xmlns="http://www.w3schools.com"
+           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+           xsi:schemaLocation="http://www.w3schools.com algorithm_schema.xsd">
+
+    <iterations>2000</iterations>
+
+    <construction>
+        <insertion name="bestInsertion"/>
+    </construction>
+
+    <strategy>
+        <memory>1</memory>
+        <searchStrategies>
+            <searchStrategy name="randomRuinAndRecreate">
+                <selector name="selectBest"/>
+                <acceptor name="schrimpfAcceptance">
+                    <alpha>0.4</alpha>
+                    <warmup>100</warmup>
+                </acceptor>
+                <modules>
+                    <module name="ruin_and_recreate">
+                        <ruin name="randomRuin">
+                            <share>0.5</share>
+                        </ruin>
+                        <insertion name="bestInsertion"/>
+                    </module>
+
+                </modules>
+                <probability>0.5</probability>
+            </searchStrategy>
+
+            <searchStrategy name="radialRuinAndRecreate">
+                <selector name="selectBest"/>
+                <acceptor name="schrimpfAcceptance"/>
+                <modules>
+                    <module name="ruin_and_recreate">
+                        <ruin name="radialRuin">
+                            <share>0.3</share>
+                        </ruin>
+                        <insertion name="bestInsertion"/>
+                    </module>
+
+                </modules>
+                <probability>0.5</probability>
+            </searchStrategy>
+
+        </searchStrategies>
+    </strategy>
+
+
+</algorithm>

jsprit-io/src/main/resources/vrp_xml_schema.xsd

@@ -0,0 +1,405 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<!--~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+  ~ 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/>.
+  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-->
+
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" targetNamespace="http://www.w3schools.com"
+           xmlns="http://www.w3schools.com" elementFormDefault="qualified">
+
+    <xs:element name="problem">
+        <xs:complexType>
+            <xs:sequence>
+                <xs:element name="problemType" minOccurs="0" maxOccurs="1">
+                    <xs:complexType>
+                        <xs:sequence>
+                            <xs:element name="fleetSize">
+                                <xs:simpleType>
+                                    <xs:restriction base="xs:string">
+                                        <xs:enumeration value="INFINITE"/>
+                                        <xs:enumeration value="FINITE"/>
+                                    </xs:restriction>
+                                </xs:simpleType>
+                            </xs:element>
+                            <xs:element name="fleetComposition" minOccurs="0" maxOccurs="1">
+                                <xs:simpleType>
+                                    <xs:restriction base="xs:string">
+                                        <xs:enumeration value="HOMOGENEOUS"/>
+                                        <xs:enumeration value="HETEROGENEOUS"/>
+                                    </xs:restriction>
+                                </xs:simpleType>
+
+                            </xs:element>
+                        </xs:sequence>
+                    </xs:complexType>
+                </xs:element>
+
+                <xs:element name="vehicles" minOccurs="0" maxOccurs="1">
+                    <xs:complexType>
+                        <xs:sequence>
+                            <xs:element name="vehicle" minOccurs="1" maxOccurs="unbounded">
+                                <xs:complexType>
+                                    <xs:all>
+                                        <xs:element name="id" type="xs:string" minOccurs="1" maxOccurs="1"/>
+                                        <xs:element name="location" type="locationType" minOccurs="0" maxOccurs="1"/>
+                                        <xs:element name="startLocation" type="locationType" minOccurs="0"
+                                                    maxOccurs="1"/>
+                                        <xs:element name="endLocation" type="locationType" minOccurs="0" maxOccurs="1"/>
+                                        <xs:element name="typeId" type="xs:string" minOccurs="1" maxOccurs="1"/>
+                                        <xs:element name="timeSchedule" type="timeWindowType"/>
+                                        <xs:element name="returnToDepot" type="xs:boolean" minOccurs="0" maxOccurs="1"/>
+                                        <xs:element name="skills" type="xs:string" minOccurs="0" maxOccurs="1"/>
+                                        <xs:element name="breaks" type="breaksType" minOccurs="0" maxOccurs="1"/>
+                                    </xs:all>
+                                    <xs:attribute name="type" type="xs:string" use="optional"/>
+                                </xs:complexType>
+                            </xs:element>
+
+                        </xs:sequence>
+                    </xs:complexType>
+                </xs:element>
+
+                <xs:element name="vehicleTypes" minOccurs="0" maxOccurs="1">
+                    <xs:complexType>
+                        <xs:sequence>
+                            <xs:element name="type" minOccurs="1" maxOccurs="unbounded">
+                                <xs:complexType>
+                                    <xs:all>
+                                        <xs:element name="id" type="xs:string" minOccurs="1" maxOccurs="1"/>
+                                        <xs:element name="capacity" type="xs:integer" minOccurs="0" maxOccurs="1"
+                                                    default="0"/>
+                                        <xs:element name="capacity-dimensions" minOccurs="0" maxOccurs="1">
+                                            <xs:complexType>
+                                                <xs:sequence>
+                                                    <xs:element name="dimension" minOccurs="1" maxOccurs="unbounded">
+                                                        <xs:complexType>
+                                                            <xs:simpleContent>
+                                                                <xs:extension base="xs:integer">
+                                                                    <xs:attribute name="index" type="xs:integer"
+                                                                                  use="required"/>
+                                                                </xs:extension>
+                                                            </xs:simpleContent>
+                                                        </xs:complexType>
+                                                    </xs:element>
+                                                </xs:sequence>
+                                            </xs:complexType>
+                                        </xs:element>
+                                        <xs:element name="costs">
+                                            <xs:complexType>
+                                                <xs:all>
+                                                    <xs:element name="fixed" type="xs:decimal" minOccurs="0"
+                                                                maxOccurs="1" default="0.0"/>
+                                                    <xs:element name="distance" type="xs:decimal" minOccurs="0"
+                                                                maxOccurs="1" default="0.0"/>
+                                                    <xs:element name="time" type="xs:decimal" minOccurs="0"
+                                                                maxOccurs="1" default="0.0"/>
+                                                    <xs:element name="service" type="xs:decimal" minOccurs="0"
+                                                                maxOccurs="1" default="0.0"/>
+                                                    <xs:element name="wait" type="xs:decimal" minOccurs="0"
+                                                                maxOccurs="1" default="0.0"/>
+                                                </xs:all>
+                                            </xs:complexType>
+                                        </xs:element>
+                                    </xs:all>
+                                    <xs:attribute name="type" type="xs:string" use="optional"/>
+                                    <xs:attribute name="penaltyFactor" type="xs:string" use="optional"/>
+                                </xs:complexType>
+                            </xs:element>
+                        </xs:sequence>
+                    </xs:complexType>
+                </xs:element>
+
+                <xs:element name="services" minOccurs="0" maxOccurs="1">
+                    <xs:complexType>
+                        <xs:sequence>
+                            <xs:element name="service" minOccurs="0" maxOccurs="unbounded">
+                                <xs:complexType>
+                                    <xs:all>
+                                        <xs:element name="location" type="locationType" minOccurs="0" maxOccurs="1"/>
+                                        <xs:element name="locationId" type="xs:string" minOccurs="0" maxOccurs="1"/>
+                                        <xs:element name="coord" type="coordType" minOccurs="0" maxOccurs="1"/>
+                                        <xs:element name="name" type="xs:string" minOccurs="0" maxOccurs="1"/>
+                                        <xs:element name="capacity-demand" type="xs:integer" minOccurs="0" maxOccurs="1"
+                                                    default="0"/>
+                                        <xs:element name="capacity-dimensions" minOccurs="0" maxOccurs="1">
+                                            <xs:complexType>
+                                                <xs:sequence>
+                                                    <xs:element name="dimension" minOccurs="1" maxOccurs="unbounded">
+                                                        <xs:complexType>
+                                                            <xs:simpleContent>
+                                                                <xs:extension base="xs:integer">
+                                                                    <xs:attribute name="index" type="xs:integer"
+                                                                                  use="required"/>
+                                                                </xs:extension>
+                                                            </xs:simpleContent>
+                                                        </xs:complexType>
+                                                    </xs:element>
+                                                </xs:sequence>
+                                            </xs:complexType>
+                                        </xs:element>
+                                        <xs:element name="duration" type="xs:decimal" minOccurs="0" maxOccurs="1"
+                                                    default="0.0"/>
+                                        <xs:element name="timeWindows" minOccurs="0" maxOccurs="1">
+                                            <xs:complexType>
+                                                <xs:sequence>
+                                                    <xs:element name="timeWindow" type="timeWindowType" minOccurs="1"
+                                                                maxOccurs="unbounded"/>
+                                                </xs:sequence>
+                                            </xs:complexType>
+                                        </xs:element>
+                                        <xs:element name="requiredSkills" type="xs:string" minOccurs="0" maxOccurs="1"/>
+                                    </xs:all>
+                                    <xs:attribute name="id" type="xs:string" use="required"/>
+                                    <xs:attribute name="type" type="xs:string"/>
+                                </xs:complexType>
+                            </xs:element>
+                        </xs:sequence>
+                    </xs:complexType>
+                </xs:element>
+
+                <xs:element name="shipments" minOccurs="0" maxOccurs="1">
+                    <xs:complexType>
+                        <xs:sequence>
+                            <xs:element name="shipment" minOccurs="0" maxOccurs="unbounded">
+                                <xs:complexType>
+                                    <xs:all>
+                                        <xs:element name="pickup" minOccurs="1" maxOccurs="1">
+                                            <xs:complexType>
+                                                <xs:all>
+                                                    <xs:element name="location" type="locationType" minOccurs="0"
+                                                                maxOccurs="1"/>
+                                                    <xs:element name="locationId" type="xs:string" minOccurs="0"
+                                                                maxOccurs="1"/>
+                                                    <xs:element name="coord" type="coordType" minOccurs="0"
+                                                                maxOccurs="1"/>
+                                                    <xs:element name="duration" type="xs:decimal" minOccurs="0"
+                                                                maxOccurs="1" default="0.0"/>
+                                                    <xs:element name="timeWindows" minOccurs="0" maxOccurs="1">
+                                                        <xs:complexType>
+                                                            <xs:sequence>
+                                                                <xs:element name="timeWindow" type="timeWindowType"
+                                                                            minOccurs="1" maxOccurs="unbounded"/>
+                                                            </xs:sequence>
+                                                        </xs:complexType>
+                                                    </xs:element>
+                                                </xs:all>
+                                            </xs:complexType>
+                                        </xs:element>
+                                        <xs:element name="delivery" minOccurs="1" maxOccurs="1">
+                                            <xs:complexType>
+                                                <xs:all>
+                                                    <xs:element name="location" type="locationType" minOccurs="0"
+                                                                maxOccurs="1"/>
+                                                    <xs:element name="locationId" type="xs:string" minOccurs="0"
+                                                                maxOccurs="1"/>
+                                                    <xs:element name="coord" type="coordType" minOccurs="0"
+                                                                maxOccurs="1"/>
+                                                    <xs:element name="duration" type="xs:decimal" minOccurs="0"
+                                                                maxOccurs="1" default="0.0"/>
+                                                    <xs:element name="timeWindows" minOccurs="0" maxOccurs="1">
+                                                        <xs:complexType>
+                                                            <xs:sequence>
+                                                                <xs:element name="timeWindow" type="timeWindowType"
+                                                                            minOccurs="1" maxOccurs="unbounded"/>
+                                                            </xs:sequence>
+                                                        </xs:complexType>
+                                                    </xs:element>
+                                                </xs:all>
+                                            </xs:complexType>
+                                        </xs:element>
+                                        <xs:element name="capacity-demand" type="xs:integer" minOccurs="0"
+                                                    maxOccurs="1"/>
+                                        <xs:element name="capacity-dimensions" minOccurs="0" maxOccurs="1">
+                                            <xs:complexType>
+                                                <xs:sequence>
+                                                    <xs:element name="dimension" minOccurs="1" maxOccurs="unbounded">
+                                                        <xs:complexType>
+                                                            <xs:simpleContent>
+                                                                <xs:extension base="xs:integer">
+                                                                    <xs:attribute name="index" type="xs:integer"
+                                                                                  use="required"/>
+                                                                </xs:extension>
+                                                            </xs:simpleContent>
+                                                        </xs:complexType>
+                                                    </xs:element>
+                                                </xs:sequence>
+                                            </xs:complexType>
+                                        </xs:element>
+                                        <xs:element name="requiredSkills" type="xs:string" minOccurs="0" maxOccurs="1"/>
+                                        <xs:element name="name" type="xs:string" minOccurs="0" maxOccurs="1"/>
+                                    </xs:all>
+                                    <xs:attribute name="id" type="xs:string" use="required"/>
+                                </xs:complexType>
+                            </xs:element>
+                        </xs:sequence>
+                    </xs:complexType>
+                </xs:element>
+
+                <xs:element name="initialRoutes" minOccurs="0" maxOccurs="1">
+                    <xs:complexType>
+                        <xs:sequence>
+                            <xs:element name="route" minOccurs="0" maxOccurs="unbounded">
+                                <xs:complexType>
+                                    <xs:sequence>
+                                        <xs:element name="driverId" type="xs:string" minOccurs="1" maxOccurs="1"/>
+                                        <xs:element name="vehicleId" type="xs:string" minOccurs="1" maxOccurs="1"/>
+                                        <xs:element name="start" type="xs:double" minOccurs="1" maxOccurs="1"/>
+                                        <xs:element name="act" minOccurs="0" maxOccurs="unbounded">
+                                            <xs:complexType>
+                                                <xs:choice>
+                                                    <xs:group ref="serviceActGroup"/>
+                                                    <xs:group ref="shipmentActGroup"/>
+                                                    <xs:group ref="breakActGroup"/>
+                                                </xs:choice>
+                                                <xs:attribute name="type" type="xs:string" use="required"/>
+                                            </xs:complexType>
+                                        </xs:element>
+                                        <xs:element name="end" type="xs:anySimpleType" minOccurs="1" maxOccurs="1"/>
+                                    </xs:sequence>
+                                </xs:complexType>
+                            </xs:element>
+                        </xs:sequence>
+                    </xs:complexType>
+                </xs:element>
+
+                <xs:element name="solutions" minOccurs="0" maxOccurs="1">
+                    <xs:complexType>
+                        <xs:sequence>
+                            <xs:element name="solution" minOccurs="0" maxOccurs="unbounded">
+                                <xs:complexType>
+                                    <xs:sequence>
+                                        <xs:element name="cost" type="xs:decimal"/>
+                                        <xs:element name="routes" minOccurs="0" maxOccurs="1">
+                                            <xs:complexType>
+                                                <xs:sequence>
+                                                    <xs:element name="route" minOccurs="0" maxOccurs="unbounded">
+                                                        <xs:complexType>
+                                                            <xs:sequence>
+                                                                <xs:element name="cost" type="xs:double" minOccurs="0"
+                                                                            maxOccurs="1"/>
+                                                                <xs:element name="driverId" type="xs:string"
+                                                                            minOccurs="1" maxOccurs="1"/>
+                                                                <xs:element name="vehicleId" type="xs:string"
+                                                                            minOccurs="1" maxOccurs="1"/>
+                                                                <xs:element name="start" type="xs:double" minOccurs="1"
+                                                                            maxOccurs="1"/>
+                                                                <xs:element name="act" minOccurs="0"
+                                                                            maxOccurs="unbounded">
+                                                                    <xs:complexType>
+                                                                        <xs:choice>
+                                                                            <xs:group ref="serviceActGroup"/>
+                                                                            <xs:group ref="shipmentActGroup"/>
+                                                                            <xs:group ref="breakActGroup"/>
+
+                                                                        </xs:choice>
+                                                                        <xs:attribute name="type" type="xs:string"
+                                                                                      use="required"/>
+                                                                    </xs:complexType>
+                                                                </xs:element>
+                                                                <xs:element name="end" type="xs:double" minOccurs="1"
+                                                                            maxOccurs="1"/>
+                                                            </xs:sequence>
+                                                        </xs:complexType>
+                                                    </xs:element>
+                                                </xs:sequence>
+                                            </xs:complexType>
+                                        </xs:element>
+                                        <xs:element name="unassignedJobs" minOccurs="0" maxOccurs="1">
+                                            <xs:complexType>
+                                                <xs:sequence>
+                                                    <xs:element name="job" minOccurs="0" maxOccurs="unbounded">
+                                                        <xs:complexType>
+                                                            <xs:attribute name="id" type="xs:string" use="required"/>
+                                                        </xs:complexType>
+                                                    </xs:element>
+                                                </xs:sequence>
+                                            </xs:complexType>
+                                        </xs:element>
+                                    </xs:sequence>
+
+                                </xs:complexType>
+
+                            </xs:element>
+
+                        </xs:sequence>
+
+                    </xs:complexType>
+
+
+                </xs:element>
+            </xs:sequence>
+        </xs:complexType>
+    </xs:element>
+
+    <xs:group name="serviceActGroup">
+        <xs:sequence>
+            <xs:element name="serviceId" type="xs:string" minOccurs="1" maxOccurs="1"/>
+            <xs:element name="arrTime" type="xs:double" minOccurs="0" maxOccurs="1"/>
+            <xs:element name="endTime" type="xs:double" minOccurs="0" maxOccurs="1"/>
+        </xs:sequence>
+    </xs:group>
+
+    <xs:group name="shipmentActGroup">
+        <xs:sequence>
+            <xs:element name="shipmentId" type="xs:string" minOccurs="1" maxOccurs="1"/>
+            <xs:element name="arrTime" type="xs:double" minOccurs="0" maxOccurs="1"/>
+            <xs:element name="endTime" type="xs:double" minOccurs="0" maxOccurs="1"/>
+        </xs:sequence>
+    </xs:group>
+
+    <xs:group name="breakActGroup">
+        <xs:sequence>
+            <xs:element name="breakId" type="xs:string" minOccurs="1" maxOccurs="1"/>
+            <xs:element name="arrTime" type="xs:double" minOccurs="0" maxOccurs="1"/>
+            <xs:element name="endTime" type="xs:double" minOccurs="0" maxOccurs="1"/>
+        </xs:sequence>
+    </xs:group>
+
+    <xs:complexType name="timeWindowType">
+        <xs:sequence>
+            <xs:element name="start" type="xs:double"/>
+            <xs:element name="end" type="xs:double"/>
+        </xs:sequence>
+    </xs:complexType>
+
+    <xs:complexType name="locationType">
+        <xs:all>
+            <xs:element name="id" type="xs:string" minOccurs="0" maxOccurs="1"/>
+            <xs:element name="coord" type="coordType" minOccurs="0" maxOccurs="1"/>
+            <xs:element name="index" type="xs:int" minOccurs="0" maxOccurs="1"/>
+        </xs:all>
+    </xs:complexType>
+
+    <xs:complexType name="breaksType">
+        <xs:sequence>
+            <xs:element name="timeWindows" minOccurs="0" maxOccurs="1">
+                <xs:complexType>
+	                <xs:sequence>
+	                  <xs:element name="timeWindow" type="timeWindowType" minOccurs="1"
+	                          maxOccurs="unbounded"/>
+	                </xs:sequence>
+                </xs:complexType>
+              </xs:element>
+            <xs:element name="duration" type="xs:double" minOccurs="1" maxOccurs="1" default="0.0"/>
+        </xs:sequence>
+    </xs:complexType>
+
+    <xs:complexType name="coordType">
+        <xs:attribute name="x" type="xs:double" use="required"/>
+        <xs:attribute name="y" type="xs:double" use="required"/>
+    </xs:complexType>
+
+</xs:schema>

jsprit-io/src/test/java/com/graphhopper/jsprit/io/algorithm/TestAlgorithmReader.java

@@ -0,0 +1,285 @@
+/*******************************************************************************
+ * 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/>.
+ ******************************************************************************/
+package com.graphhopper.jsprit.io.algorithm;
+
+import com.graphhopper.jsprit.core.algorithm.SearchStrategy;
+import com.graphhopper.jsprit.core.algorithm.SearchStrategyModule;
+import com.graphhopper.jsprit.core.algorithm.VehicleRoutingAlgorithm;
+import com.graphhopper.jsprit.core.algorithm.acceptor.GreedyAcceptance;
+import com.graphhopper.jsprit.core.algorithm.acceptor.SolutionAcceptor;
+import com.graphhopper.jsprit.core.algorithm.listener.IterationEndsListener;
+import com.graphhopper.jsprit.core.algorithm.listener.SearchStrategyModuleListener;
+import com.graphhopper.jsprit.core.algorithm.ruin.RuinStrategy;
+import com.graphhopper.jsprit.core.algorithm.ruin.listener.RuinListener;
+import com.graphhopper.jsprit.core.algorithm.selector.SelectBest;
+import com.graphhopper.jsprit.core.algorithm.selector.SolutionSelector;
+import com.graphhopper.jsprit.core.problem.VehicleRoutingProblem;
+import com.graphhopper.jsprit.core.problem.job.Job;
+import com.graphhopper.jsprit.core.problem.solution.VehicleRoutingProblemSolution;
+import com.graphhopper.jsprit.core.problem.solution.route.VehicleRoute;
+import com.graphhopper.jsprit.io.algorithm.VehicleRoutingAlgorithms.ModKey;
+import com.graphhopper.jsprit.io.algorithm.VehicleRoutingAlgorithms.TypedMap.AcceptorKey;
+import com.graphhopper.jsprit.io.algorithm.VehicleRoutingAlgorithms.TypedMap.RuinStrategyKey;
+import com.graphhopper.jsprit.io.algorithm.VehicleRoutingAlgorithms.TypedMap.SelectorKey;
+import com.graphhopper.jsprit.io.algorithm.VehicleRoutingAlgorithms.TypedMap.StrategyModuleKey;
+import com.graphhopper.jsprit.io.problem.VrpXMLReader;
+import junit.framework.Assert;
+import org.apache.commons.configuration.ConfigurationException;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.Collection;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+
+public class TestAlgorithmReader {
+
+    AlgorithmConfig config;
+
+    VehicleRoutingProblem vrp;
+
+    Collection<VehicleRoutingProblemSolution> solutions;
+
+    @Before
+    public void doBefore() throws ConfigurationException {
+        config = new AlgorithmConfig();
+        new AlgorithmConfigXmlReader(config).setSchemaValidation(false).read(getClass().getResource("testConfig.xml"));
+        VehicleRoutingProblem.Builder vrpBuilder = VehicleRoutingProblem.Builder.newInstance();
+        solutions = new ArrayList<VehicleRoutingProblemSolution>();
+        new VrpXMLReader(vrpBuilder, solutions).read(getClass().getResourceAsStream("finiteVrp.xml"));
+        vrp = vrpBuilder.build();
+    }
+
+    @Test
+    public void itShouldReadMaxIterations() {
+        VehicleRoutingAlgorithm vra = VehicleRoutingAlgorithms.readAndCreateAlgorithm(vrp, getClass().getResource("algorithmConfigForReaderTest.xml"));
+        Assert.assertEquals(2000, vra.getMaxIterations());
+    }
+
+    static class IterationCounter implements IterationEndsListener {
+
+        int iterations = 0;
+
+        @Override
+        public void informIterationEnds(int i, VehicleRoutingProblem problem, Collection<VehicleRoutingProblemSolution> solutions) {
+            iterations = i;
+        }
+
+    }
+
+    @Test
+    public void whenSettingPrematureBreak_itShouldReadTermination() {
+        VehicleRoutingAlgorithm vra = VehicleRoutingAlgorithms.readAndCreateAlgorithm(vrp, getClass().getResource("algorithmConfigForReaderTest2.xml"));
+        IterationCounter iCounter = new IterationCounter();
+        vra.addListener(iCounter);
+        vra.searchSolutions();
+        Assert.assertEquals(100, iCounter.iterations);
+    }
+
+    @Test
+    public void itShouldReadTermination() {
+        VehicleRoutingAlgorithm vra = VehicleRoutingAlgorithms.readAndCreateAlgorithm(vrp, getClass().getResource("algorithmConfigForReaderTest.xml"));
+        IterationCounter iCounter = new IterationCounter();
+        vra.addListener(iCounter);
+        vra.searchSolutions();
+        Assert.assertEquals(25, iCounter.iterations);
+    }
+
+
+    @Test
+    public void testTypedMap() {
+        VehicleRoutingAlgorithms.TypedMap typedMap = new VehicleRoutingAlgorithms.TypedMap();
+
+        String acceptorName = "acceptor";
+        String acceptorId = "acceptorId";
+
+        ModKey key = new ModKey(acceptorName, acceptorId);
+        AcceptorKey accKey = new AcceptorKey(key);
+
+        SolutionAcceptor acceptor = new GreedyAcceptance(1);
+
+        typedMap.put(accKey, acceptor);
+
+        assertEquals(acceptor, typedMap.get(accKey));
+
+    }
+
+    @Test
+    public void testTypedMap2() {
+        VehicleRoutingAlgorithms.TypedMap typedMap = new VehicleRoutingAlgorithms.TypedMap();
+
+        String acceptorName = "acceptor";
+        String acceptorId = "acceptorId";
+
+        String selectorName = "selector";
+        String selectorId = "selectorId";
+
+        ModKey key = new ModKey(acceptorName, acceptorId);
+        AcceptorKey accKey = new AcceptorKey(key);
+        SolutionAcceptor acceptor = new GreedyAcceptance(1);
+
+        SelectorKey selKey = new SelectorKey(new ModKey(selectorName, selectorId));
+        SolutionSelector selector = new SelectBest();
+
+        typedMap.put(accKey, acceptor);
+        typedMap.put(selKey, selector);
+
+        assertEquals(acceptor, typedMap.get(accKey));
+        assertEquals(selector, typedMap.get(selKey));
+    }
+
+    @Test
+    public void testTypedMap3() {
+        VehicleRoutingAlgorithms.TypedMap typedMap = new VehicleRoutingAlgorithms.TypedMap();
+
+        String acceptorName = "acceptor";
+        String acceptorId = "acceptorId";
+
+        String acceptorName2 = "acceptor2";
+        String acceptorId2 = "acceptorId2";
+
+        String selectorName = "selector";
+        String selectorId = "selectorId";
+
+        ModKey key = new ModKey(acceptorName, acceptorId);
+        AcceptorKey accKey = new AcceptorKey(key);
+        SolutionAcceptor acceptor = new GreedyAcceptance(1);
+
+        SelectorKey selKey = new SelectorKey(new ModKey(selectorName, selectorId));
+        SolutionSelector selector = new SelectBest();
+
+        AcceptorKey accKey2 = new AcceptorKey(new ModKey(acceptorName2, acceptorId2));
+        SolutionAcceptor acceptor2 = new GreedyAcceptance(1);
+
+        typedMap.put(accKey, acceptor);
+        typedMap.put(selKey, selector);
+        typedMap.put(accKey2, acceptor2);
+
+        assertEquals(acceptor, typedMap.get(accKey));
+        assertEquals(selector, typedMap.get(selKey));
+        assertEquals(acceptor2, typedMap.get(accKey2));
+    }
+
+    @Test
+    public void testTypedMap4() {
+        VehicleRoutingAlgorithms.TypedMap typedMap = new VehicleRoutingAlgorithms.TypedMap();
+
+        String acceptorName = "acceptor";
+        String acceptorId = "acceptorId";
+
+        ModKey key = new ModKey(acceptorName, acceptorId);
+        RuinStrategyKey accKey = new RuinStrategyKey(key);
+        RuinStrategy acceptor = new RuinStrategy() {
+
+            @Override
+            public Collection<Job> ruin(Collection<VehicleRoute> vehicleRoutes) {
+                return null;
+            }
+
+
+            @Override
+            public void addListener(RuinListener ruinListener) {
+
+            }
+
+            @Override
+            public void removeListener(RuinListener ruinListener) {
+
+            }
+
+            @Override
+            public Collection<RuinListener> getListeners() {
+                return null;
+            }
+
+        };
+
+        StrategyModuleKey moduleKey = new StrategyModuleKey(key);
+        SearchStrategyModule stratModule = new SearchStrategyModule() {
+
+            @Override
+            public VehicleRoutingProblemSolution runAndGetSolution(VehicleRoutingProblemSolution vrpSolution) {
+                return null;
+            }
+
+            @Override
+            public String getName() {
+                return null;
+            }
+
+            @Override
+            public void addModuleListener(
+                SearchStrategyModuleListener moduleListener) {
+
+            }
+        };
+
+        typedMap.put(accKey, acceptor);
+        typedMap.put(moduleKey, stratModule);
+        typedMap.put(moduleKey, stratModule);
+
+        assertEquals(acceptor, typedMap.get(accKey));
+        assertEquals(stratModule, typedMap.get(moduleKey));
+
+    }
+
+    @Test
+    public void initialiseConstructionAlgoCorrectly() {
+        VehicleRoutingAlgorithms.createAlgorithm(vrp, config);
+        assertTrue(true);
+    }
+
+    @Test
+    public void whenCreatingAlgorithm_nOfStrategiesIsCorrect() {
+        VehicleRoutingAlgorithm algo = VehicleRoutingAlgorithms.createAlgorithm(vrp, config);
+        assertEquals(3, algo.getSearchStrategyManager().getStrategies().size());
+    }
+
+    @Test
+    public void whenCreatingAlgorithm_nOfIterationsIsReadCorrectly() {
+        VehicleRoutingAlgorithm algo = VehicleRoutingAlgorithms.createAlgorithm(vrp, config);
+        assertEquals(10, algo.getMaxIterations());
+    }
+
+    @Test
+    public void whenCreatingAlgorithm_nOfStrategyModulesIsCorrect() {
+        VehicleRoutingAlgorithm algo = VehicleRoutingAlgorithms.createAlgorithm(vrp, config);
+        int nOfModules = 0;
+        for (SearchStrategy strat : algo.getSearchStrategyManager().getStrategies()) {
+            nOfModules += strat.getSearchStrategyModules().size();
+        }
+        assertEquals(3, nOfModules);
+    }
+
+    @Test
+    public void readerTest_whenReadingAlgoWithSchemaValidation_itReadsCorrectly() {
+        AlgorithmConfig algoConfig = new AlgorithmConfig();
+        new AlgorithmConfigXmlReader(algoConfig).read(getClass().getResource("algorithmConfig.xml"));
+
+    }
+
+    @Test
+    public void readerTest_whenReadingAlgoWithSchemaValidationWithoutIterations_itReadsCorrectly() {
+        AlgorithmConfig algoConfig = new AlgorithmConfig();
+        new AlgorithmConfigXmlReader(algoConfig).read(getClass().getResource("algorithmConfig_withoutIterations.xml"));
+
+    }
+
+}

jsprit-io/src/test/java/com/graphhopper/jsprit/io/problem/FiniteVehicleFleetManagerIdentifiesDistinctVehicle_IT.java

@@ -0,0 +1,56 @@
+/*******************************************************************************
+ * 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 com.graphhopper.jsprit.io.problem;
+
+import com.graphhopper.jsprit.core.algorithm.VehicleRoutingAlgorithm;
+import com.graphhopper.jsprit.core.algorithm.box.Jsprit;
+import com.graphhopper.jsprit.core.algorithm.recreate.NoSolutionFoundException;
+import com.graphhopper.jsprit.core.problem.VehicleRoutingProblem;
+import com.graphhopper.jsprit.core.problem.solution.VehicleRoutingProblemSolution;
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+
+import static org.junit.Assert.assertTrue;
+
+public class FiniteVehicleFleetManagerIdentifiesDistinctVehicle_IT {
+
+    @Test
+    public void whenEmployingVehicleWhereOnlyOneDistinctVehicleCanServeAParticularJobWith_jspritAlgorithmShouldFoundDistinctSolution() {
+        final List<Boolean> testFailed = new ArrayList<Boolean>();
+        for (int i = 0; i < 10; i++) {
+            VehicleRoutingProblem.Builder vrpBuilder = VehicleRoutingProblem.Builder.newInstance();
+            new VrpXMLReader(vrpBuilder).read(getClass().getResourceAsStream("biggerProblem.xml"));
+            VehicleRoutingProblem vrp = vrpBuilder.build();
+
+            VehicleRoutingAlgorithm vra = Jsprit.createAlgorithm(vrp);
+            vra.setMaxIterations(10);
+            try {
+                @SuppressWarnings("unused")
+                Collection<VehicleRoutingProblemSolution> solutions = vra.searchSolutions();
+            } catch (NoSolutionFoundException e) {
+                testFailed.add(true);
+            }
+        }
+        assertTrue(testFailed.isEmpty());
+    }
+
+}

jsprit-io/src/test/java/com/graphhopper/jsprit/io/problem/InitialRoutesTest.java

@@ -0,0 +1,119 @@
+/*******************************************************************************
+ * 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/>.
+ ******************************************************************************/
+
+package com.graphhopper.jsprit.io.problem;
+
+
+import com.graphhopper.jsprit.core.problem.AbstractActivity;
+import com.graphhopper.jsprit.core.problem.VehicleRoutingProblem;
+import com.graphhopper.jsprit.core.problem.job.Job;
+import com.graphhopper.jsprit.core.problem.job.Service;
+import com.graphhopper.jsprit.core.problem.job.Shipment;
+import org.junit.Test;
+
+import java.util.List;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+public class InitialRoutesTest {
+
+
+    @Test
+    public void whenReading_jobMapShouldOnlyContainJob2() {
+
+        VehicleRoutingProblem.Builder vrpBuilder = VehicleRoutingProblem.Builder.newInstance();
+        new VrpXMLReader(vrpBuilder).read(getClass().getResourceAsStream("simpleProblem_iniRoutes.xml"));
+        VehicleRoutingProblem vrp = vrpBuilder.build();
+
+        assertEquals(1, getNuServices(vrp));
+        assertTrue(vrp.getJobs().containsKey("2"));
+    }
+
+    @Test
+    public void whenReadingProblem2_jobMapShouldContain_service2() {
+
+        VehicleRoutingProblem.Builder vrpBuilder = VehicleRoutingProblem.Builder.newInstance();
+        new VrpXMLReader(vrpBuilder).read(getClass().getResourceAsStream("simpleProblem_inclShipments_iniRoutes.xml"));
+        VehicleRoutingProblem vrp = vrpBuilder.build();
+
+        assertEquals(1, getNuServices(vrp));
+        assertTrue(vrp.getJobs().containsKey("2"));
+    }
+
+    @Test
+    public void whenReading_jobMapShouldContain_shipment4() {
+
+        VehicleRoutingProblem.Builder vrpBuilder = VehicleRoutingProblem.Builder.newInstance();
+        new VrpXMLReader(vrpBuilder).read(getClass().getResourceAsStream("simpleProblem_inclShipments_iniRoutes.xml"));
+        VehicleRoutingProblem vrp = vrpBuilder.build();
+
+        assertEquals(1, getNuShipments(vrp));
+        assertTrue(vrp.getJobs().containsKey("4"));
+    }
+
+    private int getNuShipments(VehicleRoutingProblem vrp) {
+        int nuShipments = 0;
+        for (Job job : vrp.getJobs().values()) {
+            if (job instanceof Shipment) nuShipments++;
+        }
+        return nuShipments;
+    }
+
+    private int getNuServices(VehicleRoutingProblem vrp) {
+        int nuServices = 0;
+        for (Job job : vrp.getJobs().values()) {
+            if (job instanceof Service) nuServices++;
+        }
+        return nuServices;
+    }
+
+    @Test
+    public void whenReading_thereShouldBeOnlyOneActAssociatedToJob2() {
+
+        VehicleRoutingProblem.Builder vrpBuilder = VehicleRoutingProblem.Builder.newInstance();
+        new VrpXMLReader(vrpBuilder).read(getClass().getResourceAsStream("simpleProblem_iniRoutes.xml"));
+        VehicleRoutingProblem vrp = vrpBuilder.build();
+
+        assertEquals(1, vrp.getActivities(vrp.getJobs().get("2")).size());
+    }
+
+    @Test
+    public void whenReading_thereShouldBeOnlyOneActAssociatedToJob2_v2() {
+
+        VehicleRoutingProblem.Builder vrpBuilder = VehicleRoutingProblem.Builder.newInstance();
+        new VrpXMLReader(vrpBuilder).read(getClass().getResourceAsStream("simpleProblem_inclShipments_iniRoutes.xml"));
+        VehicleRoutingProblem vrp = vrpBuilder.build();
+
+        assertEquals(1, vrp.getActivities(vrp.getJobs().get("2")).size());
+    }
+
+    @Test
+    public void whenReading_thereShouldBeTwoActsAssociatedToShipment4() {
+
+        VehicleRoutingProblem.Builder vrpBuilder = VehicleRoutingProblem.Builder.newInstance();
+        new VrpXMLReader(vrpBuilder).read(getClass().getResourceAsStream("simpleProblem_inclShipments_iniRoutes.xml"));
+        VehicleRoutingProblem vrp = vrpBuilder.build();
+
+        Job job = vrp.getJobs().get("4");
+        List<AbstractActivity> activities = vrp.getActivities(job);
+
+        assertEquals(2, activities.size());
+    }
+
+
+}

jsprit-io/src/test/java/com/graphhopper/jsprit/io/problem/VrpXMLReaderTest.java

@@ -0,0 +1,639 @@
+/*******************************************************************************
+ * 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/>.
+ ******************************************************************************/
+package com.graphhopper.jsprit.io.problem;
+
+import com.graphhopper.jsprit.core.problem.VehicleRoutingProblem;
+import com.graphhopper.jsprit.core.problem.VehicleRoutingProblem.FleetSize;
+import com.graphhopper.jsprit.core.problem.job.Job;
+import com.graphhopper.jsprit.core.problem.job.Service;
+import com.graphhopper.jsprit.core.problem.job.Shipment;
+import com.graphhopper.jsprit.core.problem.solution.VehicleRoutingProblemSolution;
+import com.graphhopper.jsprit.core.problem.solution.route.activity.DeliverShipment;
+import com.graphhopper.jsprit.core.problem.solution.route.activity.PickupService;
+import com.graphhopper.jsprit.core.problem.solution.route.activity.PickupShipment;
+import com.graphhopper.jsprit.core.problem.solution.route.activity.TourActivity;
+import com.graphhopper.jsprit.core.problem.vehicle.Vehicle;
+import com.graphhopper.jsprit.core.util.Solutions;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.io.InputStream;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+
+import static org.junit.Assert.*;
+
+
+public class VrpXMLReaderTest {
+
+    private InputStream inputStream;
+
+    @Before
+    public void doBefore() {
+        inputStream = getClass().getResourceAsStream("finiteVrpForReaderTest.xml");
+    }
+
+    @Test
+    public void shouldReadNameOfService() {
+        VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance();
+        new VrpXMLReader(builder, null).read(inputStream);
+        VehicleRoutingProblem vrp = builder.build();
+        Service s = (Service) vrp.getJobs().get("1");
+        assertTrue(s.getName().equals("cleaning"));
+    }
+
+    @Test
+    public void shouldReadNameOfShipment() {
+        VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance();
+        new VrpXMLReader(builder, null).read(inputStream);
+        VehicleRoutingProblem vrp = builder.build();
+        Shipment s = (Shipment) vrp.getJobs().get("3");
+        assertTrue(s.getName().equals("deliver-smth"));
+    }
+
+    @Test
+    public void whenReadingVrp_problemTypeIsReadCorrectly() {
+        VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance();
+        new VrpXMLReader(builder, null).read(inputStream);
+        VehicleRoutingProblem vrp = builder.build();
+        assertEquals(FleetSize.FINITE, vrp.getFleetSize());
+    }
+
+    @Test
+    public void whenReadingVrp_vehiclesAreReadCorrectly() {
+        VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance();
+        new VrpXMLReader(builder, null).read(inputStream);
+        VehicleRoutingProblem vrp = builder.build();
+        assertEquals(5, vrp.getVehicles().size());
+        assertTrue(idsInCollection(Arrays.asList("v1", "v2"), vrp.getVehicles()));
+    }
+
+    @Test
+    public void whenReadingVrp_vehiclesAreReadCorrectly2() {
+        VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance();
+        new VrpXMLReader(builder, null).read(inputStream);
+        VehicleRoutingProblem vrp = builder.build();
+        Vehicle v1 = getVehicle("v1", vrp.getVehicles());
+        assertEquals(20, v1.getType().getCapacityDimensions().get(0));
+        assertEquals(100.0, v1.getStartLocation().getCoordinate().getX(), 0.01);
+        assertEquals(0.0, v1.getEarliestDeparture(), 0.01);
+        assertEquals("depotLoc2", v1.getStartLocation().getId());
+        assertNotNull(v1.getType());
+        assertEquals("vehType", v1.getType().getTypeId());
+        assertNotNull(v1.getStartLocation());
+        assertEquals(1, v1.getStartLocation().getIndex());
+        assertEquals(1000.0, v1.getLatestArrival(), 0.01);
+    }
+
+    @Test
+    public void whenReadingVehicles_skill1ShouldBeAssigned() {
+        VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance();
+        new VrpXMLReader(builder, null).read(inputStream);
+        VehicleRoutingProblem vrp = builder.build();
+        Vehicle v1 = getVehicle("v1", vrp.getVehicles());
+        assertTrue(v1.getSkills().containsSkill("skill1"));
+    }
+
+    @Test
+    public void whenReadingVehicles_skill2ShouldBeAssigned() {
+        VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance();
+        new VrpXMLReader(builder, null).read(inputStream);
+        VehicleRoutingProblem vrp = builder.build();
+        Vehicle v1 = getVehicle("v1", vrp.getVehicles());
+        assertTrue(v1.getSkills().containsSkill("skill2"));
+    }
+
+    @Test
+    public void whenReadingVehicles_nuSkillsShouldBeCorrect() {
+        VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance();
+        new VrpXMLReader(builder, null).read(inputStream);
+        VehicleRoutingProblem vrp = builder.build();
+        Vehicle v1 = getVehicle("v1", vrp.getVehicles());
+        assertEquals(2, v1.getSkills().values().size());
+    }
+
+    @Test
+    public void whenReadingVehicles_nuSkillsOfV2ShouldBeCorrect() {
+        VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance();
+        new VrpXMLReader(builder, null).read(inputStream);
+        VehicleRoutingProblem vrp = builder.build();
+        Vehicle v = getVehicle("v2", vrp.getVehicles());
+        assertEquals(0, v.getSkills().values().size());
+    }
+
+    private Vehicle getVehicle(String string, Collection<Vehicle> vehicles) {
+        for (Vehicle v : vehicles) if (string.equals(v.getId())) return v;
+        return null;
+    }
+
+    private boolean idsInCollection(List<String> asList, Collection<Vehicle> vehicles) {
+        List<String> ids = new ArrayList<String>(asList);
+        for (Vehicle v : vehicles) {
+            if (ids.contains(v.getId())) ids.remove(v.getId());
+        }
+        return ids.isEmpty();
+    }
+
+    @Test
+    public void whenReadingVrp_vehicleTypesAreReadCorrectly() {
+        VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance();
+        new VrpXMLReader(builder, null).read(inputStream);
+        VehicleRoutingProblem vrp = builder.build();
+        assertEquals(3, vrp.getTypes().size());
+    }
+
+    @Test
+    public void whenReadingVrpWithInfiniteSize_itReadsCorrectly() {
+        VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance();
+        new VrpXMLReader(builder, null).read(inputStream);
+        VehicleRoutingProblem vrp = builder.build();
+        assertEquals(FleetSize.FINITE, vrp.getFleetSize());
+    }
+
+    @Test
+    public void whenReadingJobs_nuOfJobsIsReadThemCorrectly() {
+        VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance();
+        new VrpXMLReader(builder, null).read(inputStream);
+        VehicleRoutingProblem vrp = builder.build();
+        assertEquals(4, vrp.getJobs().size());
+    }
+
+    @Test
+    public void whenReadingServices_itReadsThemCorrectly() {
+        VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance();
+        new VrpXMLReader(builder, null).read(inputStream);
+        VehicleRoutingProblem vrp = builder.build();
+        int servCounter = 0;
+        for (Job j : vrp.getJobs().values()) {
+            if (j instanceof Service) servCounter++;
+        }
+        assertEquals(2, servCounter);
+    }
+
+    @Test
+    public void whenReadingService1_skill1ShouldBeAssigned() {
+        VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance();
+        new VrpXMLReader(builder, null).read(inputStream);
+        VehicleRoutingProblem vrp = builder.build();
+        Service s = (Service) vrp.getJobs().get("1");
+        assertTrue(s.getRequiredSkills().containsSkill("skill1"));
+    }
+
+    @Test
+    public void whenReadingService1_skill2ShouldBeAssigned() {
+        VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance();
+        new VrpXMLReader(builder, null).read(inputStream);
+        VehicleRoutingProblem vrp = builder.build();
+        Service s = (Service) vrp.getJobs().get("1");
+        assertTrue(s.getRequiredSkills().containsSkill("skill2"));
+    }
+
+    @Test
+    public void whenReadingService1_nuSkillsShouldBeCorrect() {
+        VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance();
+        new VrpXMLReader(builder, null).read(inputStream);
+        VehicleRoutingProblem vrp = builder.build();
+        Service s = (Service) vrp.getJobs().get("1");
+        assertEquals(2, s.getRequiredSkills().values().size());
+    }
+
+    @Test
+    public void whenReadingService2_nuSkillsOfV2ShouldBeCorrect() {
+        VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance();
+        new VrpXMLReader(builder, null).read(inputStream);
+        VehicleRoutingProblem vrp = builder.build();
+        Service s = (Service) vrp.getJobs().get("2");
+        assertEquals(0, s.getRequiredSkills().values().size());
+    }
+
+    @Test
+    public void whenReadingShipments_itReadsThemCorrectly() {
+        VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance();
+        new VrpXMLReader(builder, null).read(inputStream);
+        VehicleRoutingProblem vrp = builder.build();
+        int shipCounter = 0;
+        for (Job j : vrp.getJobs().values()) {
+            if (j instanceof Shipment) shipCounter++;
+        }
+        assertEquals(2, shipCounter);
+    }
+
+    @Test
+    public void whenReadingShipment3_skill1ShouldBeAssigned() {
+        VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance();
+        new VrpXMLReader(builder, null).read(inputStream);
+        VehicleRoutingProblem vrp = builder.build();
+        Shipment s = (Shipment) vrp.getJobs().get("3");
+        assertTrue(s.getRequiredSkills().containsSkill("skill1"));
+    }
+
+    @Test
+    public void whenReadingShipment3_skill2ShouldBeAssigned() {
+        VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance();
+        new VrpXMLReader(builder, null).read(inputStream);
+        VehicleRoutingProblem vrp = builder.build();
+        Shipment s = (Shipment) vrp.getJobs().get("3");
+        assertTrue(s.getRequiredSkills().containsSkill("skill2"));
+    }
+
+    @Test
+    public void whenReadingShipment3_nuSkillsShouldBeCorrect() {
+        VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance();
+        new VrpXMLReader(builder, null).read(inputStream);
+        VehicleRoutingProblem vrp = builder.build();
+        Shipment s = (Shipment) vrp.getJobs().get("3");
+        assertEquals(2, s.getRequiredSkills().values().size());
+    }
+
+    @Test
+    public void whenReadingShipment4_nuSkillsOfV2ShouldBeCorrect() {
+        VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance();
+        new VrpXMLReader(builder, null).read(inputStream);
+        VehicleRoutingProblem vrp = builder.build();
+        Shipment s = (Shipment) vrp.getJobs().get("4");
+        assertEquals(0, s.getRequiredSkills().values().size());
+    }
+
+    @Test
+    public void whenReadingServices_capOfService1IsReadCorrectly() {
+        VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance();
+        new VrpXMLReader(builder, null).read(inputStream);
+        VehicleRoutingProblem vrp = builder.build();
+        Service s1 = (Service) vrp.getJobs().get("1");
+        assertEquals(1, s1.getSize().get(0));
+    }
+
+    @Test
+    public void whenReadingServices_durationOfService1IsReadCorrectly() {
+        VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance();
+        new VrpXMLReader(builder, null).read(inputStream);
+        VehicleRoutingProblem vrp = builder.build();
+        Service s1 = (Service) vrp.getJobs().get("1");
+        assertEquals(10.0, s1.getServiceDuration(), 0.01);
+    }
+
+    @Test
+    public void whenReadingServices_twOfService1IsReadCorrectly() {
+        VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance();
+        new VrpXMLReader(builder, null).read(inputStream);
+        VehicleRoutingProblem vrp = builder.build();
+        Service s1 = (Service) vrp.getJobs().get("1");
+        assertEquals(0.0, s1.getTimeWindow().getStart(), 0.01);
+        assertEquals(4000.0, s1.getTimeWindow().getEnd(), 0.01);
+    }
+
+    @Test
+    public void whenReadingServices_typeOfService1IsReadCorrectly() {
+        VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance();
+        new VrpXMLReader(builder, null).read(inputStream);
+        VehicleRoutingProblem vrp = builder.build();
+        Service s1 = (Service) vrp.getJobs().get("1");
+        assertEquals("service", s1.getType());
+    }
+
+    @Test
+    public void whenReadingFile_v2MustNotReturnToDepot() {
+        VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance();
+        new VrpXMLReader(builder, null).read(inputStream);
+        VehicleRoutingProblem vrp = builder.build();
+        Vehicle v = getVehicle("v2", vrp.getVehicles());
+        assertFalse(v.isReturnToDepot());
+    }
+
+    @Test
+    public void whenReadingFile_v3HasTheCorrectStartLocation() {
+        VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance();
+        new VrpXMLReader(builder, null).read(inputStream);
+        VehicleRoutingProblem vrp = builder.build();
+        Vehicle v3 = getVehicle("v3", vrp.getVehicles());
+        assertEquals("startLoc", v3.getStartLocation().getId());
+        assertNotNull(v3.getEndLocation());
+        assertEquals(4, v3.getEndLocation().getIndex());
+    }
+
+    @Test
+    public void whenReadingFile_v3HasTheCorrectEndLocation() {
+        VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance();
+        new VrpXMLReader(builder, null).read(inputStream);
+        VehicleRoutingProblem vrp = builder.build();
+        Vehicle v3 = getVehicle("v3", vrp.getVehicles());
+        assertEquals("endLoc", v3.getEndLocation().getId());
+    }
+
+    @Test
+    public void whenReadingFile_v3HasTheCorrectEndLocationCoordinate() {
+        VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance();
+        new VrpXMLReader(builder, null).read(inputStream);
+        VehicleRoutingProblem vrp = builder.build();
+        Vehicle v3 = getVehicle("v3", vrp.getVehicles());
+        assertEquals(1000.0, v3.getEndLocation().getCoordinate().getX(), 0.01);
+        assertEquals(2000.0, v3.getEndLocation().getCoordinate().getY(), 0.01);
+    }
+
+    @Test
+    public void whenReadingFile_v3HasTheCorrectStartLocationCoordinate() {
+        VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance();
+        new VrpXMLReader(builder, null).read(inputStream);
+        VehicleRoutingProblem vrp = builder.build();
+        Vehicle v3 = getVehicle("v3", vrp.getVehicles());
+        assertEquals(10.0, v3.getStartLocation().getCoordinate().getX(), 0.01);
+        assertEquals(100.0, v3.getStartLocation().getCoordinate().getY(), 0.01);
+    }
+
+    @Test
+    public void whenReadingFile_v3HasTheCorrectLocationCoordinate() {
+        VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance();
+        new VrpXMLReader(builder, null).read(inputStream);
+        VehicleRoutingProblem vrp = builder.build();
+        Vehicle v3 = getVehicle("v3", vrp.getVehicles());
+        assertEquals(10.0, v3.getStartLocation().getCoordinate().getX(), 0.01);
+        assertEquals(100.0, v3.getStartLocation().getCoordinate().getY(), 0.01);
+    }
+
+    @Test
+    public void whenReadingFile_v3HasTheCorrectLocationId() {
+        VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance();
+        new VrpXMLReader(builder, null).read(inputStream);
+        VehicleRoutingProblem vrp = builder.build();
+        Vehicle v3 = getVehicle("v3", vrp.getVehicles());
+        assertEquals("startLoc", v3.getStartLocation().getId());
+    }
+
+    @Test
+    public void whenReadingFile_v4HasTheCorrectStartLocation() {
+        VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance();
+        new VrpXMLReader(builder, null).read(inputStream);
+        VehicleRoutingProblem vrp = builder.build();
+        Vehicle v = getVehicle("v4", vrp.getVehicles());
+        assertEquals("startLoc", v.getStartLocation().getId());
+    }
+
+    @Test
+    public void whenReadingFile_v4HasTheCorrectEndLocation() {
+        VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance();
+        new VrpXMLReader(builder, null).read(inputStream);
+        VehicleRoutingProblem vrp = builder.build();
+        Vehicle v = getVehicle("v4", vrp.getVehicles());
+        assertEquals("endLoc", v.getEndLocation().getId());
+    }
+
+    @Test
+    public void whenReadingFile_v4HasTheCorrectEndLocationCoordinate() {
+        VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance();
+        new VrpXMLReader(builder, null).read(inputStream);
+        VehicleRoutingProblem vrp = builder.build();
+        Vehicle v = getVehicle("v4", vrp.getVehicles());
+        assertEquals(1000.0, v.getEndLocation().getCoordinate().getX(), 0.01);
+        assertEquals(2000.0, v.getEndLocation().getCoordinate().getY(), 0.01);
+    }
+
+    @Test
+    public void whenReadingFile_v4HasTheCorrectStartLocationCoordinate() {
+        VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance();
+        new VrpXMLReader(builder, null).read(inputStream);
+        VehicleRoutingProblem vrp = builder.build();
+        Vehicle v = getVehicle("v4", vrp.getVehicles());
+        assertEquals(10.0, v.getStartLocation().getCoordinate().getX(), 0.01);
+        assertEquals(100.0, v.getStartLocation().getCoordinate().getY(), 0.01);
+    }
+
+    @Test
+    public void whenReadingFile_v4HasTheCorrectLocationCoordinate() {
+        VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance();
+        new VrpXMLReader(builder, null).read(inputStream);
+        VehicleRoutingProblem vrp = builder.build();
+        Vehicle v = getVehicle("v4", vrp.getVehicles());
+        assertEquals(10.0, v.getStartLocation().getCoordinate().getX(), 0.01);
+        assertEquals(100.0, v.getStartLocation().getCoordinate().getY(), 0.01);
+    }
+
+    @Test
+    public void whenReadingFile_v4HasTheCorrectLocationId() {
+        VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance();
+        new VrpXMLReader(builder, null).read(inputStream);
+        VehicleRoutingProblem vrp = builder.build();
+        Vehicle v = getVehicle("v4", vrp.getVehicles());
+        assertEquals("startLoc", v.getStartLocation().getId());
+    }
+
+    @Test
+    public void whenReadingJobs_capOfShipment3IsReadCorrectly() {
+        VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance();
+        new VrpXMLReader(builder, null).read(inputStream);
+        VehicleRoutingProblem vrp = builder.build();
+        Shipment s = (Shipment) vrp.getJobs().get("3");
+        assertEquals(10, s.getSize().get(0));
+    }
+
+    @Test
+    public void whenReadingJobs_pickupServiceTimeOfShipment3IsReadCorrectly() {
+        VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance();
+        new VrpXMLReader(builder, null).read(inputStream);
+        VehicleRoutingProblem vrp = builder.build();
+        Shipment s = (Shipment) vrp.getJobs().get("3");
+        assertEquals(10.0, s.getPickupServiceTime(), 0.01);
+    }
+
+    @Test
+    public void whenReadingJobs_pickupTimeWindowOfShipment3IsReadCorrectly() {
+        VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance();
+        new VrpXMLReader(builder, null).read(inputStream);
+        VehicleRoutingProblem vrp = builder.build();
+        Shipment s = (Shipment) vrp.getJobs().get("3");
+        assertEquals(1000.0, s.getPickupTimeWindow().getStart(), 0.01);
+        assertEquals(4000.0, s.getPickupTimeWindow().getEnd(), 0.01);
+    }
+
+    @Test
+    public void whenReadingJobs_deliveryTimeWindowOfShipment3IsReadCorrectly() {
+        VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance();
+        new VrpXMLReader(builder, null).read(inputStream);
+        VehicleRoutingProblem vrp = builder.build();
+        Shipment s = (Shipment) vrp.getJobs().get("3");
+        assertEquals(6000.0, s.getDeliveryTimeWindow().getStart(), 0.01);
+        assertEquals(10000.0, s.getDeliveryTimeWindow().getEnd(), 0.01);
+    }
+
+    @Test
+    public void whenReadingJobs_deliveryServiceTimeOfShipment3IsReadCorrectly() {
+        VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance();
+        new VrpXMLReader(builder, null).read(inputStream);
+        VehicleRoutingProblem vrp = builder.build();
+        Shipment s = (Shipment) vrp.getJobs().get("3");
+        assertEquals(100.0, s.getDeliveryServiceTime(), 0.01);
+    }
+
+    @Test
+    public void whenReadingJobs_deliveryCoordShipment3IsReadCorrectly() {
+        VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance();
+        new VrpXMLReader(builder, null).read(inputStream);
+        VehicleRoutingProblem vrp = builder.build();
+        Shipment s = (Shipment) vrp.getJobs().get("3");
+        assertEquals(10.0, s.getDeliveryLocation().getCoordinate().getX(), 0.01);
+        assertEquals(0.0, s.getDeliveryLocation().getCoordinate().getY(), 0.01);
+    }
+
+    @Test
+    public void whenReadingJobs_pickupCoordShipment3IsReadCorrectly() {
+        VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance();
+        new VrpXMLReader(builder, null).read(inputStream);
+        VehicleRoutingProblem vrp = builder.build();
+        Shipment s = (Shipment) vrp.getJobs().get("3");
+        assertEquals(10.0, s.getPickupLocation().getCoordinate().getX(), 0.01);
+        assertEquals(10.0, s.getPickupLocation().getCoordinate().getY(), 0.01);
+    }
+
+    @Test
+    public void whenReadingJobs_deliveryIdShipment3IsReadCorrectly() {
+        VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance();
+        new VrpXMLReader(builder, null).read(inputStream);
+        VehicleRoutingProblem vrp = builder.build();
+        Shipment s = (Shipment) vrp.getJobs().get("3");
+        assertEquals("i(9,9)", s.getDeliveryLocation().getId());
+    }
+
+    @Test
+    public void whenReadingJobs_pickupIdShipment3IsReadCorrectly() {
+        VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance();
+        new VrpXMLReader(builder, null).read(inputStream);
+        VehicleRoutingProblem vrp = builder.build();
+        Shipment s = (Shipment) vrp.getJobs().get("3");
+        assertEquals("i(3,9)", s.getPickupLocation().getId());
+    }
+
+    @Test
+    public void whenReadingJobs_pickupLocationIdShipment4IsReadCorrectly() {
+        VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance();
+        new VrpXMLReader(builder, null).read(inputStream);
+        VehicleRoutingProblem vrp = builder.build();
+        Shipment s = (Shipment) vrp.getJobs().get("4");
+        assertEquals("[x=10.0][y=10.0]", s.getPickupLocation().getId());
+    }
+
+    @Test
+    public void whenReadingJobs_deliveryLocationIdShipment4IsReadCorrectly() {
+        VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance();
+        new VrpXMLReader(builder, null).read(inputStream);
+        VehicleRoutingProblem vrp = builder.build();
+        Shipment s = (Shipment) vrp.getJobs().get("4");
+        assertEquals("[x=10.0][y=0.0]", s.getDeliveryLocation().getId());
+    }
+
+    @Test
+    public void whenReadingJobs_pickupServiceTimeOfShipment4IsReadCorrectly() {
+        VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance();
+        new VrpXMLReader(builder, null).read(inputStream);
+        VehicleRoutingProblem vrp = builder.build();
+        Shipment s = (Shipment) vrp.getJobs().get("4");
+        assertEquals(0.0, s.getPickupServiceTime(), 0.01);
+    }
+
+    @Test
+    public void whenReadingJobs_deliveryServiceTimeOfShipment4IsReadCorrectly() {
+        VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance();
+        new VrpXMLReader(builder, null).read(inputStream);
+        VehicleRoutingProblem vrp = builder.build();
+        Shipment s = (Shipment) vrp.getJobs().get("4");
+        assertEquals(100.0, s.getDeliveryServiceTime(), 0.01);
+    }
+
+    @Test
+    public void whenReadingFile_v5AndItsTypeHasTheCorrectCapacityDimensionValues() {
+        VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance();
+        new VrpXMLReader(builder, null).read(inputStream);
+        VehicleRoutingProblem vrp = builder.build();
+        Vehicle v = getVehicle("v5", vrp.getVehicles());
+        assertEquals(100, v.getType().getCapacityDimensions().get(0));
+        assertEquals(1000, v.getType().getCapacityDimensions().get(1));
+        assertEquals(10000, v.getType().getCapacityDimensions().get(2));
+        assertEquals(0, v.getType().getCapacityDimensions().get(3));
+        assertEquals(0, v.getType().getCapacityDimensions().get(5));
+        assertEquals(100000, v.getType().getCapacityDimensions().get(10));
+    }
+
+    @Test
+    public void whenReadingInitialRouteWithShipment4_thisShipmentShouldNotAppearInJobMap() { //since it is not part of the problem anymore
+        VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance();
+        new VrpXMLReader(builder).read(getClass().getResourceAsStream("finiteVrpWithInitialSolutionForReaderTest.xml"));
+        VehicleRoutingProblem vrp = builder.build();
+        assertFalse(vrp.getJobs().containsKey("4"));
+    }
+
+    @Test
+    public void whenReadingInitialRouteWithDepTime10_departureTimeOfRouteShouldBeReadCorrectly() {
+        VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance();
+        new VrpXMLReader(builder).read(getClass().getResourceAsStream("finiteVrpWithInitialSolutionForReaderTest.xml"));
+        VehicleRoutingProblem vrp = builder.build();
+        assertEquals(10., vrp.getInitialVehicleRoutes().iterator().next().getDepartureTime(), 0.01);
+    }
+
+    @Test
+    public void whenReadingInitialRoute_nuInitialRoutesShouldBeCorrect() {
+        VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance();
+        new VrpXMLReader(builder, null).read(getClass().getResourceAsStream("finiteVrpWithInitialSolutionForReaderTest.xml"));
+        VehicleRoutingProblem vrp = builder.build();
+        assertEquals(1, vrp.getInitialVehicleRoutes().size());
+    }
+
+    @Test
+    public void whenReadingInitialRoute_nuActivitiesShouldBeCorrect() {
+        VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance();
+        new VrpXMLReader(builder, null).read(getClass().getResourceAsStream("finiteVrpWithInitialSolutionForReaderTest.xml"));
+        VehicleRoutingProblem vrp = builder.build();
+        assertEquals(2, vrp.getInitialVehicleRoutes().iterator().next().getActivities().size());
+    }
+
+    @Test
+    public void testRead_ifReaderIsCalled_itReadsSuccessfullyV2() {
+        VehicleRoutingProblem.Builder vrpBuilder = VehicleRoutingProblem.Builder.newInstance();
+        ArrayList<VehicleRoutingProblemSolution> solutions = new ArrayList<VehicleRoutingProblemSolution>();
+        new VrpXMLReader(vrpBuilder, solutions).read(getClass().getResourceAsStream("finiteVrpWithShipmentsAndSolution.xml"));
+        VehicleRoutingProblem vrp = vrpBuilder.build();
+        assertEquals(4, vrp.getJobs().size());
+        assertEquals(1, solutions.size());
+
+        assertEquals(1, solutions.get(0).getRoutes().size());
+        List<TourActivity> activities = solutions.get(0).getRoutes().iterator().next().getTourActivities().getActivities();
+        assertEquals(4, activities.size());
+        assertTrue(activities.get(0) instanceof PickupService);
+        assertTrue(activities.get(1) instanceof PickupService);
+        assertTrue(activities.get(2) instanceof PickupShipment);
+        assertTrue(activities.get(3) instanceof DeliverShipment);
+    }
+
+    @Test
+    public void testRead_ifReaderIsCalled_itReadsSuccessfully() {
+        new VrpXMLReader(VehicleRoutingProblem.Builder.newInstance(), new ArrayList<VehicleRoutingProblemSolution>()).read(getClass().getResourceAsStream("lui-shen-solution.xml"));
+        assertTrue(true);
+    }
+
+
+    @Test
+    public void unassignedJobShouldBeRead() {
+        VehicleRoutingProblem.Builder vrpBuilder = VehicleRoutingProblem.Builder.newInstance();
+        ArrayList<VehicleRoutingProblemSolution> solutions = new ArrayList<VehicleRoutingProblemSolution>();
+        new VrpXMLReader(vrpBuilder, solutions).read(getClass().getResourceAsStream("finiteVrpWithShipmentsAndSolution.xml"));
+
+        VehicleRoutingProblemSolution solution = Solutions.bestOf(solutions);
+        assertEquals(1, solution.getUnassignedJobs().size());
+        assertEquals("4", solution.getUnassignedJobs().iterator().next().getId());
+    }
+}
+
+//

jsprit-io/src/test/java/com/graphhopper/jsprit/io/problem/VrpXMLWriterTest.java

@@ -0,0 +1,962 @@
+/*******************************************************************************
+ * 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/>.
+ ******************************************************************************/
+package com.graphhopper.jsprit.io.problem;
+
+import com.graphhopper.jsprit.core.problem.Location;
+import com.graphhopper.jsprit.core.problem.VehicleRoutingProblem;
+import com.graphhopper.jsprit.core.problem.job.Service;
+import com.graphhopper.jsprit.core.problem.job.Shipment;
+import com.graphhopper.jsprit.core.problem.solution.VehicleRoutingProblemSolution;
+import com.graphhopper.jsprit.core.problem.solution.route.VehicleRoute;
+import com.graphhopper.jsprit.core.problem.solution.route.activity.TimeWindow;
+import com.graphhopper.jsprit.core.problem.vehicle.Vehicle;
+import com.graphhopper.jsprit.core.problem.vehicle.VehicleImpl;
+import com.graphhopper.jsprit.core.problem.vehicle.VehicleTypeImpl;
+import com.graphhopper.jsprit.core.util.Coordinate;
+import com.graphhopper.jsprit.core.util.Solutions;
+import com.graphhopper.jsprit.io.util.TestUtils;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+
+import static org.junit.Assert.*;
+
+public class VrpXMLWriterTest {
+
+    private String infileName;
+
+    @Before
+    public void doBefore() {
+        infileName = "src/test/resources/infiniteWriterV2Test.xml";
+    }
+
+    @Test
+    public void whenWritingInfiniteVrp_itWritesCorrectly() {
+        VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance();
+        builder.setFleetSize(VehicleRoutingProblem.FleetSize.INFINITE);
+        VehicleTypeImpl type = VehicleTypeImpl.Builder.newInstance("vehType").addCapacityDimension(0, 20).build();
+        VehicleImpl vehicle = VehicleImpl.Builder.newInstance("myVehicle").setStartLocation(TestUtils.loc("loc")).setType(type).build();
+        builder.addVehicle(vehicle);
+        VehicleRoutingProblem vrp = builder.build();
+        new VrpXMLWriter(vrp, null).write(infileName);
+    }
+
+    @Test
+    public void whenWritingFiniteVrp_itWritesCorrectly() {
+        VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance();
+        builder.setFleetSize(VehicleRoutingProblem.FleetSize.FINITE);
+        VehicleTypeImpl type1 = VehicleTypeImpl.Builder.newInstance("vehType").addCapacityDimension(0, 20).build();
+        VehicleTypeImpl type2 = VehicleTypeImpl.Builder.newInstance("vehType2").addCapacityDimension(0, 200).build();
+        VehicleImpl v1 = VehicleImpl.Builder.newInstance("v1").setStartLocation(TestUtils.loc("loc")).setType(type1).build();
+        VehicleImpl v2 = VehicleImpl.Builder.newInstance("v2").setStartLocation(TestUtils.loc("loc")).setType(type2).build();
+        builder.addVehicle(v1);
+        builder.addVehicle(v2);
+        VehicleRoutingProblem vrp = builder.build();
+        new VrpXMLWriter(vrp, null).write(infileName);
+    }
+
+    @Test
+    public void t() {
+        VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance();
+        builder.setFleetSize(VehicleRoutingProblem.FleetSize.FINITE);
+        VehicleTypeImpl type1 = VehicleTypeImpl.Builder.newInstance("vehType").addCapacityDimension(0, 20).build();
+        VehicleTypeImpl type2 = VehicleTypeImpl.Builder.newInstance("vehType2").addCapacityDimension(0, 200).build();
+        VehicleImpl v1 = VehicleImpl.Builder.newInstance("v1").setStartLocation(TestUtils.loc("loc")).setType(type1).build();
+        VehicleImpl v2 = VehicleImpl.Builder.newInstance("v2").setStartLocation(TestUtils.loc("loc")).setType(type2).build();
+        builder.addVehicle(v1);
+        builder.addVehicle(v2);
+        VehicleRoutingProblem vrp = builder.build();
+        new VrpXMLWriter(vrp, null).write(infileName);
+
+        VehicleRoutingProblem.Builder vrpToReadBuilder = VehicleRoutingProblem.Builder.newInstance();
+        new VrpXMLReader(vrpToReadBuilder, null).read(infileName);
+    }
+
+    @Test
+    public void whenWritingServices_itWritesThemCorrectly() {
+        VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance();
+
+        VehicleTypeImpl type1 = VehicleTypeImpl.Builder.newInstance("vehType").addCapacityDimension(0, 20).build();
+        VehicleTypeImpl type2 = VehicleTypeImpl.Builder.newInstance("vehType2").addCapacityDimension(0, 200).build();
+        VehicleImpl v1 = VehicleImpl.Builder.newInstance("v1").setStartLocation(TestUtils.loc("loc")).setType(type1).build();
+        VehicleImpl v2 = VehicleImpl.Builder.newInstance("v2").setStartLocation(TestUtils.loc("loc")).setType(type2).build();
+
+        builder.addVehicle(v1);
+        builder.addVehicle(v2);
+
+
+        Service s1 = Service.Builder.newInstance("1").addSizeDimension(0, 1).setLocation(TestUtils.loc("loc")).setServiceTime(2.0).build();
+        Service s2 = Service.Builder.newInstance("2").addSizeDimension(0, 1).setLocation(TestUtils.loc("loc2")).setServiceTime(4.0).build();
+
+        VehicleRoutingProblem vrp = builder.addJob(s1).addJob(s2).build();
+        new VrpXMLWriter(vrp, null).write(infileName);
+
+        VehicleRoutingProblem.Builder vrpToReadBuilder = VehicleRoutingProblem.Builder.newInstance();
+        new VrpXMLReader(vrpToReadBuilder, null).read(infileName);
+        VehicleRoutingProblem readVrp = vrpToReadBuilder.build();
+        assertEquals(2, readVrp.getJobs().size());
+
+        Service s1_read = (Service) vrp.getJobs().get("1");
+        assertEquals("1", s1_read.getId());
+        Assert.assertEquals("loc", s1_read.getLocation().getId());
+        assertEquals("service", s1_read.getType());
+        assertEquals(2.0, s1_read.getServiceDuration(), 0.01);
+    }
+
+    @Test
+    public void shouldWriteNameOfService() {
+        VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance();
+        Service s1 = Service.Builder.newInstance("1").setName("cleaning").addSizeDimension(0, 1).setLocation(TestUtils.loc("loc")).setServiceTime(2.0).build();
+
+        VehicleRoutingProblem vrp = builder.addJob(s1).build();
+        new VrpXMLWriter(vrp, null).write(infileName);
+
+        VehicleRoutingProblem.Builder vrpToReadBuilder = VehicleRoutingProblem.Builder.newInstance();
+        new VrpXMLReader(vrpToReadBuilder, null).read(infileName);
+        VehicleRoutingProblem readVrp = vrpToReadBuilder.build();
+        Service s1_read = (Service) readVrp.getJobs().get("1");
+        assertTrue(s1_read.getName().equals("cleaning"));
+    }
+
+    @Test
+    public void shouldWriteNameOfShipment() {
+        VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance();
+        Location pickLocation = Location.Builder.newInstance().setId("pick").setIndex(1).build();
+        Shipment s1 = Shipment.Builder.newInstance("1").setName("cleaning")
+            .setPickupLocation(pickLocation)
+            .setDeliveryLocation(TestUtils.loc("del")).build();
+
+        VehicleRoutingProblem vrp = builder.addJob(s1).build();
+        new VrpXMLWriter(vrp, null).write(infileName);
+
+        VehicleRoutingProblem.Builder vrpToReadBuilder = VehicleRoutingProblem.Builder.newInstance();
+        new VrpXMLReader(vrpToReadBuilder, null).read(infileName);
+        VehicleRoutingProblem readVrp = vrpToReadBuilder.build();
+        Shipment s1_read = (Shipment) readVrp.getJobs().get("1");
+        assertTrue(s1_read.getName().equals("cleaning"));
+        Assert.assertEquals(1, s1_read.getPickupLocation().getIndex());
+    }
+
+    @Test
+    public void whenWritingServicesWithSeveralCapacityDimensions_itWritesThemCorrectly() {
+        VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance();
+
+        Service s1 = Service.Builder.newInstance("1")
+            .addSizeDimension(0, 20)
+            .addSizeDimension(1, 200)
+            .setLocation(TestUtils.loc("loc")).setServiceTime(2.0).build();
+        Service s2 = Service.Builder.newInstance("2").addSizeDimension(0, 1).setLocation(TestUtils.loc("loc2")).setServiceTime(4.0).build();
+
+        VehicleRoutingProblem vrp = builder.addJob(s1).addJob(s2).build();
+        new VrpXMLWriter(vrp, null).write(infileName);
+
+        VehicleRoutingProblem.Builder vrpToReadBuilder = VehicleRoutingProblem.Builder.newInstance();
+        new VrpXMLReader(vrpToReadBuilder, null).read(infileName);
+        VehicleRoutingProblem readVrp = vrpToReadBuilder.build();
+        assertEquals(2, readVrp.getJobs().size());
+
+        Service s1_read = (Service) vrp.getJobs().get("1");
+
+        Assert.assertEquals(2, s1_read.getSize().getNuOfDimensions());
+        Assert.assertEquals(20, s1_read.getSize().get(0));
+        Assert.assertEquals(200, s1_read.getSize().get(1));
+
+    }
+
+    @Test
+    public void whenWritingShipments_readingThemAgainMustReturnTheWrittenLocationIdsOfS1() {
+        VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance();
+
+        VehicleTypeImpl type1 = VehicleTypeImpl.Builder.newInstance("vehType").addCapacityDimension(0, 20).build();
+        VehicleTypeImpl type2 = VehicleTypeImpl.Builder.newInstance("vehType2").addCapacityDimension(0, 200).build();
+        VehicleImpl v1 = VehicleImpl.Builder.newInstance("v1").setStartLocation(TestUtils.loc("loc")).setType(type1).build();
+        VehicleImpl v2 = VehicleImpl.Builder.newInstance("v2").setStartLocation(TestUtils.loc("loc")).setType(type2).build();
+
+        builder.addVehicle(v1);
+        builder.addVehicle(v2);
+
+        Shipment s1 = Shipment.Builder.newInstance("1").addSizeDimension(0, 10)
+            .setPickupLocation(Location.Builder.newInstance().setId("pickLoc").build())
+            .setDeliveryLocation(TestUtils.loc("delLoc")).setPickupTimeWindow(TimeWindow.newInstance(1, 2))
+            .setDeliveryTimeWindow(TimeWindow.newInstance(3, 4)).build();
+        Shipment s2 = Shipment.Builder.newInstance("2").addSizeDimension(0, 20)
+            .setPickupLocation(Location.Builder.newInstance().setId("pickLocation").build())
+            .setDeliveryLocation(TestUtils.loc("delLocation")).setPickupTimeWindow(TimeWindow.newInstance(5, 6))
+            .setDeliveryTimeWindow(TimeWindow.newInstance(7, 8)).build();
+
+
+        VehicleRoutingProblem vrp = builder.addJob(s1).addJob(s2).build();
+        new VrpXMLWriter(vrp, null).write(infileName);
+
+        VehicleRoutingProblem.Builder vrpToReadBuilder = VehicleRoutingProblem.Builder.newInstance();
+        new VrpXMLReader(vrpToReadBuilder, null).read(infileName);
+        VehicleRoutingProblem readVrp = vrpToReadBuilder.build();
+        assertEquals(2, readVrp.getJobs().size());
+
+        Assert.assertEquals("pickLoc", ((Shipment) readVrp.getJobs().get("1")).getPickupLocation().getId());
+        Assert.assertEquals("delLoc", ((Shipment) readVrp.getJobs().get("1")).getDeliveryLocation().getId());
+
+    }
+
+    @Test
+    public void whenWritingShipments_readingThemAgainMustReturnTheWrittenPickupTimeWindowsOfS1() {
+        VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance();
+
+        VehicleTypeImpl type1 = VehicleTypeImpl.Builder.newInstance("vehType").addCapacityDimension(0, 20).build();
+        VehicleTypeImpl type2 = VehicleTypeImpl.Builder.newInstance("vehType2").addCapacityDimension(0, 200).build();
+        VehicleImpl v1 = VehicleImpl.Builder.newInstance("v1").setStartLocation(TestUtils.loc("loc")).setType(type1).build();
+        VehicleImpl v2 = VehicleImpl.Builder.newInstance("v2").setStartLocation(TestUtils.loc("loc")).setType(type2).build();
+
+        builder.addVehicle(v1);
+        builder.addVehicle(v2);
+
+        Shipment s1 = Shipment.Builder.newInstance("1").addSizeDimension(0, 10)
+            .setPickupLocation(Location.Builder.newInstance().setId("pickLoc").build())
+            .setDeliveryLocation(TestUtils.loc("delLoc")).setPickupTimeWindow(TimeWindow.newInstance(1, 2))
+            .setDeliveryTimeWindow(TimeWindow.newInstance(3, 4)).build();
+        Shipment s2 = Shipment.Builder.newInstance("2").addSizeDimension(0, 20)
+            .setPickupLocation(Location.Builder.newInstance().setId("pickLocation").build())
+            .setDeliveryLocation(TestUtils.loc("delLocation")).setPickupTimeWindow(TimeWindow.newInstance(5, 6))
+            .setDeliveryTimeWindow(TimeWindow.newInstance(7, 8)).build();
+
+
+        VehicleRoutingProblem vrp = builder.addJob(s1).addJob(s2).build();
+        new VrpXMLWriter(vrp, null).write(infileName);
+
+        VehicleRoutingProblem.Builder vrpToReadBuilder = VehicleRoutingProblem.Builder.newInstance();
+        new VrpXMLReader(vrpToReadBuilder, null).read(infileName);
+        VehicleRoutingProblem readVrp = vrpToReadBuilder.build();
+        assertEquals(2, readVrp.getJobs().size());
+
+        Assert.assertEquals(1.0, ((Shipment) readVrp.getJobs().get("1")).getPickupTimeWindow().getStart(), 0.01);
+        Assert.assertEquals(2.0, ((Shipment) readVrp.getJobs().get("1")).getPickupTimeWindow().getEnd(), 0.01);
+
+
+    }
+
+    @Test
+    public void whenWritingShipments_readingThemAgainMustReturnTheWrittenDeliveryTimeWindowsOfS1() {
+        VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance();
+
+        VehicleTypeImpl type1 = VehicleTypeImpl.Builder.newInstance("vehType").addCapacityDimension(0, 20).build();
+        VehicleTypeImpl type2 = VehicleTypeImpl.Builder.newInstance("vehType2").addCapacityDimension(0, 200).build();
+        VehicleImpl v1 = VehicleImpl.Builder.newInstance("v1").setStartLocation(TestUtils.loc("loc")).setType(type1).build();
+        VehicleImpl v2 = VehicleImpl.Builder.newInstance("v2").setStartLocation(TestUtils.loc("loc")).setType(type2).build();
+
+        builder.addVehicle(v1);
+        builder.addVehicle(v2);
+
+        Shipment s1 = Shipment.Builder.newInstance("1").addSizeDimension(0, 10)
+            .setPickupLocation(Location.Builder.newInstance().setId("pickLoc").build())
+            .setDeliveryLocation(TestUtils.loc("delLoc")).setPickupTimeWindow(TimeWindow.newInstance(1, 2))
+            .setDeliveryTimeWindow(TimeWindow.newInstance(3, 4)).build();
+        Shipment s2 = Shipment.Builder.newInstance("2").addSizeDimension(0, 20)
+            .setPickupLocation(Location.Builder.newInstance().setId("pickLocation").build())
+            .setDeliveryLocation(TestUtils.loc("delLocation")).setPickupTimeWindow(TimeWindow.newInstance(5, 6))
+            .setDeliveryTimeWindow(TimeWindow.newInstance(7, 8)).build();
+
+
+        VehicleRoutingProblem vrp = builder.addJob(s1).addJob(s2).build();
+        new VrpXMLWriter(vrp, null).write(infileName);
+
+        VehicleRoutingProblem.Builder vrpToReadBuilder = VehicleRoutingProblem.Builder.newInstance();
+        new VrpXMLReader(vrpToReadBuilder, null).read(infileName);
+        VehicleRoutingProblem readVrp = vrpToReadBuilder.build();
+        assertEquals(2, readVrp.getJobs().size());
+
+        Assert.assertEquals(3.0, ((Shipment) readVrp.getJobs().get("1")).getDeliveryTimeWindow().getStart(), 0.01);
+        Assert.assertEquals(4.0, ((Shipment) readVrp.getJobs().get("1")).getDeliveryTimeWindow().getEnd(), 0.01);
+
+    }
+
+    @Test
+    public void whenWritingShipments_readingThemAgainMustReturnTheWrittenDeliveryServiceTimeOfS1() {
+        VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance();
+
+        VehicleTypeImpl type1 = VehicleTypeImpl.Builder.newInstance("vehType").addCapacityDimension(0, 20).build();
+        VehicleTypeImpl type2 = VehicleTypeImpl.Builder.newInstance("vehType2").addCapacityDimension(0, 200).build();
+        VehicleImpl v1 = VehicleImpl.Builder.newInstance("v1").setStartLocation(TestUtils.loc("loc")).setType(type1).build();
+        VehicleImpl v2 = VehicleImpl.Builder.newInstance("v2").setStartLocation(TestUtils.loc("loc")).setType(type2).build();
+
+        builder.addVehicle(v1);
+        builder.addVehicle(v2);
+
+        Shipment s1 = Shipment.Builder.newInstance("1").addSizeDimension(0, 10)
+            .setPickupLocation(Location.Builder.newInstance().setId("pickLoc").build())
+            .setDeliveryLocation(TestUtils.loc("delLoc")).setPickupTimeWindow(TimeWindow.newInstance(1, 2))
+            .setDeliveryTimeWindow(TimeWindow.newInstance(3, 4)).setPickupServiceTime(100).setDeliveryServiceTime(50).build();
+        Shipment s2 = Shipment.Builder.newInstance("2").addSizeDimension(0, 20)
+            .setPickupLocation(Location.Builder.newInstance().setId("pickLocation").build())
+            .setDeliveryLocation(TestUtils.loc("delLocation")).setPickupTimeWindow(TimeWindow.newInstance(5, 6))
+            .setDeliveryTimeWindow(TimeWindow.newInstance(7, 8)).build();
+
+
+        VehicleRoutingProblem vrp = builder.addJob(s1).addJob(s2).build();
+        new VrpXMLWriter(vrp, null).write(infileName);
+
+        VehicleRoutingProblem.Builder vrpToReadBuilder = VehicleRoutingProblem.Builder.newInstance();
+        new VrpXMLReader(vrpToReadBuilder, null).read(infileName);
+        VehicleRoutingProblem readVrp = vrpToReadBuilder.build();
+        assertEquals(2, readVrp.getJobs().size());
+
+        assertEquals(100.0, ((Shipment) readVrp.getJobs().get("1")).getPickupServiceTime(), 0.01);
+        assertEquals(50.0, ((Shipment) readVrp.getJobs().get("1")).getDeliveryServiceTime(), 0.01);
+
+    }
+
+    @Test
+    public void whenWritingShipments_readingThemAgainMustReturnTheWrittenLocationIdOfS1() {
+        VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance();
+
+        VehicleTypeImpl type1 = VehicleTypeImpl.Builder.newInstance("vehType").addCapacityDimension(0, 20).build();
+        VehicleTypeImpl type2 = VehicleTypeImpl.Builder.newInstance("vehType2").addCapacityDimension(0, 200).build();
+        VehicleImpl v1 = VehicleImpl.Builder.newInstance("v1").setStartLocation(TestUtils.loc("loc")).setType(type1).build();
+        VehicleImpl v2 = VehicleImpl.Builder.newInstance("v2").setStartLocation(TestUtils.loc("loc")).setType(type2).build();
+
+        builder.addVehicle(v1);
+        builder.addVehicle(v2);
+
+        Shipment s1 = Shipment.Builder.newInstance("1").addSizeDimension(0, 10)
+            .setPickupLocation(TestUtils.loc(Coordinate.newInstance(1, 2))).setDeliveryLocation(TestUtils.loc("delLoc")).setPickupTimeWindow(TimeWindow.newInstance(1, 2))
+            .setDeliveryTimeWindow(TimeWindow.newInstance(3, 4)).setPickupServiceTime(100).setDeliveryServiceTime(50).build();
+        Shipment s2 = Shipment.Builder.newInstance("2").addSizeDimension(0, 20)
+            .setPickupLocation(Location.Builder.newInstance().setId("pickLocation").build())
+            .setDeliveryLocation(TestUtils.loc("delLocation")).setPickupTimeWindow(TimeWindow.newInstance(5, 6))
+            .setDeliveryTimeWindow(TimeWindow.newInstance(7, 8)).build();
+
+
+        VehicleRoutingProblem vrp = builder.addJob(s1).addJob(s2).build();
+        new VrpXMLWriter(vrp, null).write(infileName);
+
+        VehicleRoutingProblem.Builder vrpToReadBuilder = VehicleRoutingProblem.Builder.newInstance();
+        new VrpXMLReader(vrpToReadBuilder, null).read(infileName);
+        VehicleRoutingProblem readVrp = vrpToReadBuilder.build();
+        assertEquals(2, readVrp.getJobs().size());
+
+        Assert.assertEquals("[x=1.0][y=2.0]", ((Shipment) readVrp.getJobs().get("1")).getPickupLocation().getId());
+    }
+
+    @Test
+    public void whenWritingVehicles_vehShouldHave2Skills() {
+        VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance();
+        VehicleTypeImpl type1 = VehicleTypeImpl.Builder.newInstance("vehType").addCapacityDimension(0, 20).build();
+        VehicleImpl v = VehicleImpl.Builder.newInstance("v1").addSkill("SKILL5").addSkill("skill1").addSkill("Skill2")
+            .setStartLocation(TestUtils.loc("loc")).setType(type1).build();
+        builder.addVehicle(v);
+
+        VehicleRoutingProblem vrp = builder.build();
+        new VrpXMLWriter(vrp, null).write(infileName);
+
+        VehicleRoutingProblem.Builder vrpToReadBuilder = VehicleRoutingProblem.Builder.newInstance();
+        new VrpXMLReader(vrpToReadBuilder, null).read(infileName);
+        VehicleRoutingProblem readVrp = vrpToReadBuilder.build();
+        Vehicle veh1 = getVehicle("v1", readVrp);
+
+        Assert.assertEquals(3, veh1.getSkills().values().size());
+    }
+
+    @Test
+    public void whenWritingVehicles_vehShouldContain_skill5() {
+        VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance();
+        VehicleTypeImpl type1 = VehicleTypeImpl.Builder.newInstance("vehType").addCapacityDimension(0, 20).build();
+        VehicleImpl v = VehicleImpl.Builder.newInstance("v1").addSkill("SKILL5").addSkill("skill1").addSkill("Skill2")
+            .setStartLocation(TestUtils.loc("loc")).setType(type1).build();
+        builder.addVehicle(v);
+
+        VehicleRoutingProblem vrp = builder.build();
+        new VrpXMLWriter(vrp, null).write(infileName);
+
+        VehicleRoutingProblem.Builder vrpToReadBuilder = VehicleRoutingProblem.Builder.newInstance();
+        new VrpXMLReader(vrpToReadBuilder, null).read(infileName);
+        VehicleRoutingProblem readVrp = vrpToReadBuilder.build();
+        Vehicle veh1 = getVehicle("v1", readVrp);
+
+        assertTrue(veh1.getSkills().containsSkill("skill5"));
+    }
+
+    @Test
+    public void whenWritingVehicles_vehShouldContain_skill1() {
+        VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance();
+        VehicleTypeImpl type1 = VehicleTypeImpl.Builder.newInstance("vehType").addCapacityDimension(0, 20).build();
+        VehicleImpl v = VehicleImpl.Builder.newInstance("v1").addSkill("SKILL5").addSkill("skill1").addSkill("Skill2")
+            .setStartLocation(TestUtils.loc("loc")).setType(type1).build();
+        builder.addVehicle(v);
+
+        VehicleRoutingProblem vrp = builder.build();
+        new VrpXMLWriter(vrp, null).write(infileName);
+
+        VehicleRoutingProblem.Builder vrpToReadBuilder = VehicleRoutingProblem.Builder.newInstance();
+        new VrpXMLReader(vrpToReadBuilder, null).read(infileName);
+        VehicleRoutingProblem readVrp = vrpToReadBuilder.build();
+        Vehicle veh1 = getVehicle("v1", readVrp);
+
+        assertTrue(veh1.getSkills().containsSkill("skill1"));
+    }
+
+    @Test
+    public void whenWritingVehicles_vehShouldContain_skill2() {
+        VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance();
+        VehicleTypeImpl type1 = VehicleTypeImpl.Builder.newInstance("vehType").addCapacityDimension(0, 20).build();
+        VehicleImpl v = VehicleImpl.Builder.newInstance("v1").addSkill("SKILL5").addSkill("skill1").addSkill("Skill2")
+            .setStartLocation(TestUtils.loc("loc")).setType(type1).build();
+        builder.addVehicle(v);
+
+        VehicleRoutingProblem vrp = builder.build();
+        new VrpXMLWriter(vrp, null).write(infileName);
+
+        VehicleRoutingProblem.Builder vrpToReadBuilder = VehicleRoutingProblem.Builder.newInstance();
+        new VrpXMLReader(vrpToReadBuilder, null).read(infileName);
+        VehicleRoutingProblem readVrp = vrpToReadBuilder.build();
+        Vehicle veh1 = getVehicle("v1", readVrp);
+
+        assertTrue(veh1.getSkills().containsSkill("skill2"));
+    }
+
+    @Test
+    public void whenWritingVehicles_vehShouldHave0Skills() {
+        VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance();
+        VehicleTypeImpl type1 = VehicleTypeImpl.Builder.newInstance("vehType").addCapacityDimension(0, 20).build();
+        VehicleImpl v = VehicleImpl.Builder.newInstance("v1").setStartLocation(TestUtils.loc("loc")).setType(type1).build();
+        builder.addVehicle(v);
+
+        VehicleRoutingProblem vrp = builder.build();
+        new VrpXMLWriter(vrp, null).write(infileName);
+
+        VehicleRoutingProblem.Builder vrpToReadBuilder = VehicleRoutingProblem.Builder.newInstance();
+        new VrpXMLReader(vrpToReadBuilder, null).read(infileName);
+        VehicleRoutingProblem readVrp = vrpToReadBuilder.build();
+        Vehicle veh = getVehicle("v1", readVrp);
+
+        Assert.assertEquals(0, veh.getSkills().values().size());
+    }
+
+    private Vehicle getVehicle(String v1, VehicleRoutingProblem readVrp) {
+        for (Vehicle v : readVrp.getVehicles()) {
+            if (v.getId().equals(v1)) return v;
+        }
+        return null;
+    }
+
+    @Test
+    public void whenWritingShipments_shipmentShouldHaveCorrectNuSkills() {
+        VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance();
+
+        Shipment s = Shipment.Builder.newInstance("1").addRequiredSkill("skill1").addRequiredSkill("skill2").addRequiredSkill("skill3")
+            .addSizeDimension(0, 10)
+            .setPickupLocation(TestUtils.loc(Coordinate.newInstance(1, 2)))
+            .setDeliveryLocation(TestUtils.loc("delLoc", Coordinate.newInstance(5, 6)))
+            .setPickupTimeWindow(TimeWindow.newInstance(1, 2))
+            .setDeliveryTimeWindow(TimeWindow.newInstance(3, 4)).setPickupServiceTime(100).setDeliveryServiceTime(50).build();
+
+        VehicleRoutingProblem vrp = builder.addJob(s).build();
+        new VrpXMLWriter(vrp, null).write(infileName);
+
+        VehicleRoutingProblem.Builder vrpToReadBuilder = VehicleRoutingProblem.Builder.newInstance();
+        new VrpXMLReader(vrpToReadBuilder, null).read(infileName);
+        VehicleRoutingProblem readVrp = vrpToReadBuilder.build();
+
+        Assert.assertEquals(3, readVrp.getJobs().get("1").getRequiredSkills().values().size());
+    }
+
+    @Test
+    public void whenWritingShipments_shipmentShouldContain_skill1() {
+        VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance();
+
+        Shipment s = Shipment.Builder.newInstance("1").addRequiredSkill("skill1").addRequiredSkill("skill2").addRequiredSkill("skill3")
+            .addSizeDimension(0, 10)
+            .setPickupLocation(TestUtils.loc(Coordinate.newInstance(1, 2)))
+            .setDeliveryLocation(TestUtils.loc("delLoc", Coordinate.newInstance(5, 6)))
+            .setPickupTimeWindow(TimeWindow.newInstance(1, 2))
+            .setDeliveryTimeWindow(TimeWindow.newInstance(3, 4)).setPickupServiceTime(100).setDeliveryServiceTime(50).build();
+
+        VehicleRoutingProblem vrp = builder.addJob(s).build();
+        new VrpXMLWriter(vrp, null).write(infileName);
+
+        VehicleRoutingProblem.Builder vrpToReadBuilder = VehicleRoutingProblem.Builder.newInstance();
+        new VrpXMLReader(vrpToReadBuilder, null).read(infileName);
+        VehicleRoutingProblem readVrp = vrpToReadBuilder.build();
+
+        assertTrue(readVrp.getJobs().get("1").getRequiredSkills().containsSkill("skill1"));
+    }
+
+    @Test
+    public void whenWritingShipments_shipmentShouldContain_skill2() {
+        VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance();
+
+        Shipment s = Shipment.Builder.newInstance("1").addRequiredSkill("skill1").addRequiredSkill("Skill2").addRequiredSkill("skill3")
+            .addSizeDimension(0, 10)
+            .setPickupLocation(TestUtils.loc(Coordinate.newInstance(1, 2)))
+            .setDeliveryLocation(TestUtils.loc("delLoc", Coordinate.newInstance(5, 6)))
+            .setPickupTimeWindow(TimeWindow.newInstance(1, 2))
+            .setDeliveryTimeWindow(TimeWindow.newInstance(3, 4)).setPickupServiceTime(100).setDeliveryServiceTime(50).build();
+
+        VehicleRoutingProblem vrp = builder.addJob(s).build();
+        new VrpXMLWriter(vrp, null).write(infileName);
+
+        VehicleRoutingProblem.Builder vrpToReadBuilder = VehicleRoutingProblem.Builder.newInstance();
+        new VrpXMLReader(vrpToReadBuilder, null).read(infileName);
+        VehicleRoutingProblem readVrp = vrpToReadBuilder.build();
+
+        assertTrue(readVrp.getJobs().get("1").getRequiredSkills().containsSkill("skill2"));
+    }
+
+    @Test
+    public void whenWritingShipments_shipmentShouldContain_skill3() {
+        VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance();
+
+        Shipment s = Shipment.Builder.newInstance("1").addRequiredSkill("skill1").addRequiredSkill("Skill2").addRequiredSkill("skill3")
+            .addSizeDimension(0, 10)
+            .setPickupLocation(TestUtils.loc(Coordinate.newInstance(1, 2)))
+            .setDeliveryLocation(TestUtils.loc("delLoc", Coordinate.newInstance(5, 6)))
+            .setPickupTimeWindow(TimeWindow.newInstance(1, 2))
+            .setDeliveryTimeWindow(TimeWindow.newInstance(3, 4)).setPickupServiceTime(100).setDeliveryServiceTime(50).build();
+
+        VehicleRoutingProblem vrp = builder.addJob(s).build();
+        new VrpXMLWriter(vrp, null).write(infileName);
+
+        VehicleRoutingProblem.Builder vrpToReadBuilder = VehicleRoutingProblem.Builder.newInstance();
+        new VrpXMLReader(vrpToReadBuilder, null).read(infileName);
+        VehicleRoutingProblem readVrp = vrpToReadBuilder.build();
+
+        assertTrue(readVrp.getJobs().get("1").getRequiredSkills().containsSkill("skill3"));
+    }
+
+    @Test
+    public void whenWritingShipments_readingThemAgainMustReturnTheWrittenLocationCoordinateOfS1() {
+        VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance();
+
+        VehicleTypeImpl type1 = VehicleTypeImpl.Builder.newInstance("vehType").addCapacityDimension(0, 20).build();
+        VehicleTypeImpl type2 = VehicleTypeImpl.Builder.newInstance("vehType2").addCapacityDimension(0, 200).build();
+        VehicleImpl v1 = VehicleImpl.Builder.newInstance("v1").setStartLocation(TestUtils.loc("loc")).setType(type1).build();
+        VehicleImpl v2 = VehicleImpl.Builder.newInstance("v2").setStartLocation(TestUtils.loc("loc")).setType(type2).build();
+
+        builder.addVehicle(v1);
+        builder.addVehicle(v2);
+
+        Shipment s1 = Shipment.Builder.newInstance("1").addSizeDimension(0, 10).setPickupLocation(TestUtils.loc(Coordinate.newInstance(1, 2)))
+            .setDeliveryLocation(TestUtils.loc("delLoc", Coordinate.newInstance(5, 6)))
+            .setPickupTimeWindow(TimeWindow.newInstance(1, 2))
+            .setDeliveryTimeWindow(TimeWindow.newInstance(3, 4)).setPickupServiceTime(100).setDeliveryServiceTime(50).build();
+        Shipment s2 = Shipment.Builder.newInstance("2").addSizeDimension(0, 20)
+            .setPickupLocation(Location.Builder.newInstance().setId("pickLocation").build())
+            .setDeliveryLocation(TestUtils.loc("delLocation"))
+            .setPickupTimeWindow(TimeWindow.newInstance(5, 6))
+            .setDeliveryTimeWindow(TimeWindow.newInstance(7, 8)).build();
+
+
+        VehicleRoutingProblem vrp = builder.addJob(s1).addJob(s2).build();
+        new VrpXMLWriter(vrp, null).write(infileName);
+
+        VehicleRoutingProblem.Builder vrpToReadBuilder = VehicleRoutingProblem.Builder.newInstance();
+        new VrpXMLReader(vrpToReadBuilder, null).read(infileName);
+        VehicleRoutingProblem readVrp = vrpToReadBuilder.build();
+        assertEquals(2, readVrp.getJobs().size());
+
+        Assert.assertEquals(1.0, ((Shipment) readVrp.getJobs().get("1")).getPickupLocation().getCoordinate().getX(), 0.01);
+        Assert.assertEquals(2.0, ((Shipment) readVrp.getJobs().get("1")).getPickupLocation().getCoordinate().getY(), 0.01);
+
+        Assert.assertEquals(5.0, ((Shipment) readVrp.getJobs().get("1")).getDeliveryLocation().getCoordinate().getX(), 0.01);
+        Assert.assertEquals(6.0, ((Shipment) readVrp.getJobs().get("1")).getDeliveryLocation().getCoordinate().getY(), 0.01);
+    }
+
+    @Test
+    public void whenWritingShipmentWithSeveralCapacityDimension_itShouldWriteAndReadItCorrectly() {
+        VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance();
+
+        Shipment s1 = Shipment.Builder.newInstance("1")
+            .setPickupLocation(TestUtils.loc(Coordinate.newInstance(1, 2)))
+            .setDeliveryLocation(TestUtils.loc("delLoc", Coordinate.newInstance(5, 6)))
+            .setPickupTimeWindow(TimeWindow.newInstance(1, 2))
+            .setDeliveryTimeWindow(TimeWindow.newInstance(3, 4)).setPickupServiceTime(100).setDeliveryServiceTime(50)
+            .addSizeDimension(0, 10)
+            .addSizeDimension(2, 100)
+            .build();
+
+        Shipment s2 = Shipment.Builder.newInstance("2").addSizeDimension(0, 20)
+            .setPickupLocation(Location.Builder.newInstance().setId("pickLocation").build())
+            .setDeliveryLocation(TestUtils.loc("delLocation")).setPickupTimeWindow(TimeWindow.newInstance(5, 6))
+            .setDeliveryTimeWindow(TimeWindow.newInstance(7, 8)).build();
+
+        VehicleRoutingProblem vrp = builder.addJob(s1).addJob(s2).build();
+        new VrpXMLWriter(vrp, null).write(infileName);
+
+        VehicleRoutingProblem.Builder vrpToReadBuilder = VehicleRoutingProblem.Builder.newInstance();
+        new VrpXMLReader(vrpToReadBuilder, null).read(infileName);
+        VehicleRoutingProblem readVrp = vrpToReadBuilder.build();
+
+        Assert.assertEquals(3, (readVrp.getJobs().get("1")).getSize().getNuOfDimensions());
+        Assert.assertEquals(10, (readVrp.getJobs().get("1")).getSize().get(0));
+        Assert.assertEquals(0, (readVrp.getJobs().get("1")).getSize().get(1));
+        Assert.assertEquals(100, (readVrp.getJobs().get("1")).getSize().get(2));
+
+        Assert.assertEquals(1, (readVrp.getJobs().get("2")).getSize().getNuOfDimensions());
+        Assert.assertEquals(20, (readVrp.getJobs().get("2")).getSize().get(0));
+    }
+
+    @Test
+    public void whenWritingVehicleV1_itsStartLocationMustBeWrittenCorrectly() {
+        VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance();
+
+        VehicleTypeImpl type1 = VehicleTypeImpl.Builder.newInstance("vehType").addCapacityDimension(0, 20).build();
+        VehicleTypeImpl type2 = VehicleTypeImpl.Builder.newInstance("vehType2").addCapacityDimension(0, 200).build();
+        VehicleImpl v1 = VehicleImpl.Builder.newInstance("v1").setStartLocation(TestUtils.loc("loc")).setType(type1).build();
+        VehicleImpl v2 = VehicleImpl.Builder.newInstance("v2").setStartLocation(TestUtils.loc("loc")).setType(type2).build();
+
+        builder.addVehicle(v1);
+        builder.addVehicle(v2);
+
+        Service s1 = Service.Builder.newInstance("1").addSizeDimension(0, 1).setLocation(TestUtils.loc("loc")).setServiceTime(2.0).build();
+        Service s2 = Service.Builder.newInstance("2").addSizeDimension(0, 1).setLocation(TestUtils.loc("loc2")).setServiceTime(4.0).build();
+
+        VehicleRoutingProblem vrp = builder.addJob(s1).addJob(s2).build();
+        new VrpXMLWriter(vrp, null).write(infileName);
+
+        VehicleRoutingProblem.Builder vrpToReadBuilder = VehicleRoutingProblem.Builder.newInstance();
+        new VrpXMLReader(vrpToReadBuilder, null).read(infileName);
+        VehicleRoutingProblem readVrp = vrpToReadBuilder.build();
+
+        Vehicle v = getVehicle("v1", readVrp.getVehicles());
+        Assert.assertEquals("loc", v.getStartLocation().getId());
+        Assert.assertEquals("loc", v.getEndLocation().getId());
+
+    }
+
+    @Test
+    public void whenWritingService_itShouldHaveTheCorrectNuSkills() {
+        VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance();
+
+        Service s = Service.Builder.newInstance("1").addRequiredSkill("sKill1").addRequiredSkill("skill2").addSizeDimension(0, 1)
+            .setLocation(TestUtils.loc("loc")).setServiceTime(2.0).build();
+
+        VehicleRoutingProblem vrp = builder.addJob(s).build();
+        new VrpXMLWriter(vrp, null).write(infileName);
+
+        VehicleRoutingProblem.Builder vrpToReadBuilder = VehicleRoutingProblem.Builder.newInstance();
+        new VrpXMLReader(vrpToReadBuilder, null).read(infileName);
+        VehicleRoutingProblem readVrp = vrpToReadBuilder.build();
+
+        Assert.assertEquals(2, readVrp.getJobs().get("1").getRequiredSkills().values().size());
+    }
+
+    @Test
+    public void whenWritingService_itShouldContain_skill1() {
+        VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance();
+
+        Service s = Service.Builder.newInstance("1").addRequiredSkill("sKill1").addRequiredSkill("skill2").addSizeDimension(0, 1)
+            .setLocation(TestUtils.loc("loc")).setServiceTime(2.0).build();
+
+        VehicleRoutingProblem vrp = builder.addJob(s).build();
+        new VrpXMLWriter(vrp, null).write(infileName);
+
+        VehicleRoutingProblem.Builder vrpToReadBuilder = VehicleRoutingProblem.Builder.newInstance();
+        new VrpXMLReader(vrpToReadBuilder, null).read(infileName);
+        VehicleRoutingProblem readVrp = vrpToReadBuilder.build();
+
+        assertTrue(readVrp.getJobs().get("1").getRequiredSkills().containsSkill("skill1"));
+    }
+
+    @Test
+    public void whenWritingService_itShouldContain_skill2() {
+        VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance();
+
+        Service s = Service.Builder.newInstance("1").addRequiredSkill("sKill1").addRequiredSkill("skill2").addSizeDimension(0, 1)
+            .setLocation(TestUtils.loc("loc")).setServiceTime(2.0).build();
+
+        VehicleRoutingProblem vrp = builder.addJob(s).build();
+        new VrpXMLWriter(vrp, null).write(infileName);
+
+        VehicleRoutingProblem.Builder vrpToReadBuilder = VehicleRoutingProblem.Builder.newInstance();
+        new VrpXMLReader(vrpToReadBuilder, null).read(infileName);
+        VehicleRoutingProblem readVrp = vrpToReadBuilder.build();
+
+        assertTrue(readVrp.getJobs().get("1").getRequiredSkills().containsSkill("skill2"));
+    }
+
+    @Test
+    public void whenWritingVehicleV1_itDoesNotReturnToDepotMustBeWrittenCorrectly() {
+        VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance();
+
+        VehicleTypeImpl type1 = VehicleTypeImpl.Builder.newInstance("vehType").addCapacityDimension(0, 20).build();
+        VehicleTypeImpl type2 = VehicleTypeImpl.Builder.newInstance("vehType2").addCapacityDimension(0, 200).build();
+        VehicleImpl v1 = VehicleImpl.Builder.newInstance("v1").setReturnToDepot(false).setStartLocation(TestUtils.loc("loc"))
+            .setType(type1).build();
+        VehicleImpl v2 = VehicleImpl.Builder.newInstance("v2").setStartLocation(TestUtils.loc("loc")).setType(type2).build();
+
+        builder.addVehicle(v1);
+        builder.addVehicle(v2);
+
+        Service s1 = Service.Builder.newInstance("1").addSizeDimension(0, 1).setLocation(TestUtils.loc("loc")).setServiceTime(2.0).build();
+        Service s2 = Service.Builder.newInstance("2").addSizeDimension(0, 1).setLocation(TestUtils.loc("loc2")).setServiceTime(4.0).build();
+
+        VehicleRoutingProblem vrp = builder.addJob(s1).addJob(s2).build();
+        new VrpXMLWriter(vrp, null).write(infileName);
+
+        VehicleRoutingProblem.Builder vrpToReadBuilder = VehicleRoutingProblem.Builder.newInstance();
+        new VrpXMLReader(vrpToReadBuilder, null).read(infileName);
+        VehicleRoutingProblem readVrp = vrpToReadBuilder.build();
+
+        Vehicle v = getVehicle("v1", readVrp.getVehicles());
+        assertFalse(v.isReturnToDepot());
+    }
+
+    @Test
+    public void whenWritingVehicleV1_readingAgainAssignsCorrectType() {
+        VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance();
+
+        VehicleTypeImpl type1 = VehicleTypeImpl.Builder.newInstance("vehType").addCapacityDimension(0, 20).build();
+        VehicleTypeImpl type2 = VehicleTypeImpl.Builder.newInstance("vehType2").addCapacityDimension(0, 200).build();
+        VehicleImpl v1 = VehicleImpl.Builder.newInstance("v1").setReturnToDepot(false).setStartLocation(TestUtils.loc("loc")).setType(type1).build();
+        VehicleImpl v2 = VehicleImpl.Builder.newInstance("v2").setStartLocation(TestUtils.loc("loc")).setType(type2).build();
+
+        builder.addVehicle(v1);
+        builder.addVehicle(v2);
+
+        Service s1 = Service.Builder.newInstance("1").addSizeDimension(0, 1).setLocation(TestUtils.loc("loc")).setServiceTime(2.0).build();
+        Service s2 = Service.Builder.newInstance("2").addSizeDimension(0, 1).setLocation(TestUtils.loc("loc2")).setServiceTime(4.0).build();
+
+        VehicleRoutingProblem vrp = builder.addJob(s1).addJob(s2).build();
+        new VrpXMLWriter(vrp, null).write(infileName);
+
+        VehicleRoutingProblem.Builder vrpToReadBuilder = VehicleRoutingProblem.Builder.newInstance();
+        new VrpXMLReader(vrpToReadBuilder, null).read(infileName);
+        VehicleRoutingProblem readVrp = vrpToReadBuilder.build();
+
+        Vehicle v = getVehicle("v1", readVrp.getVehicles());
+        assertEquals("vehType", v.getType().getTypeId());
+    }
+
+    @Test
+    public void whenWritingVehicleV2_readingAgainAssignsCorrectType() {
+        VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance();
+
+        VehicleTypeImpl type1 = VehicleTypeImpl.Builder.newInstance("vehType").addCapacityDimension(0, 20).build();
+        VehicleTypeImpl type2 = VehicleTypeImpl.Builder.newInstance("vehType2").addCapacityDimension(0, 200).build();
+        VehicleImpl v1 = VehicleImpl.Builder.newInstance("v1").setReturnToDepot(false).setStartLocation(TestUtils.loc("loc")).setType(type1).build();
+        VehicleImpl v2 = VehicleImpl.Builder.newInstance("v2").setStartLocation(TestUtils.loc("loc")).setType(type2).build();
+
+        builder.addVehicle(v1);
+        builder.addVehicle(v2);
+
+        Service s1 = Service.Builder.newInstance("1").addSizeDimension(0, 1).setLocation(TestUtils.loc("loc")).setServiceTime(2.0).build();
+        Service s2 = Service.Builder.newInstance("2").addSizeDimension(0, 1).setLocation(TestUtils.loc("loc2")).setServiceTime(4.0).build();
+
+        VehicleRoutingProblem vrp = builder.addJob(s1).addJob(s2).build();
+        new VrpXMLWriter(vrp, null).write(infileName);
+
+        VehicleRoutingProblem.Builder vrpToReadBuilder = VehicleRoutingProblem.Builder.newInstance();
+        new VrpXMLReader(vrpToReadBuilder, null).read(infileName);
+        VehicleRoutingProblem readVrp = vrpToReadBuilder.build();
+
+        Vehicle v = getVehicle("v2", readVrp.getVehicles());
+        assertEquals("vehType2", v.getType().getTypeId());
+        Assert.assertEquals(200, v.getType().getCapacityDimensions().get(0));
+
+    }
+
+    @Test
+    public void whenWritingVehicleV2_readingItsLocationsAgainReturnsCorrectLocations() {
+        VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance();
+
+        VehicleTypeImpl type1 = VehicleTypeImpl.Builder.newInstance("vehType").addCapacityDimension(0, 20).build();
+        VehicleTypeImpl type2 = VehicleTypeImpl.Builder.newInstance("vehType2").addCapacityDimension(0, 200).build();
+        VehicleImpl v1 = VehicleImpl.Builder.newInstance("v1").setReturnToDepot(false).setStartLocation(TestUtils.loc("loc")).setType(type1).build();
+        VehicleImpl v2 = VehicleImpl.Builder.newInstance("v2")
+            .setStartLocation(TestUtils.loc("startLoc", Coordinate.newInstance(1, 2)))
+            .setEndLocation(TestUtils.loc("endLoc", Coordinate.newInstance(4, 5))).setType(type2).build();
+
+        builder.addVehicle(v1);
+        builder.addVehicle(v2);
+
+        Service s1 = Service.Builder.newInstance("1").addSizeDimension(0, 1).setLocation(TestUtils.loc("loc")).setServiceTime(2.0).build();
+        Service s2 = Service.Builder.newInstance("2").addSizeDimension(0, 1).setLocation(TestUtils.loc("loc2")).setServiceTime(4.0).build();
+
+        VehicleRoutingProblem vrp = builder.addJob(s1).addJob(s2).build();
+        new VrpXMLWriter(vrp, null).write(infileName);
+
+        VehicleRoutingProblem.Builder vrpToReadBuilder = VehicleRoutingProblem.Builder.newInstance();
+        new VrpXMLReader(vrpToReadBuilder, null).read(infileName);
+        VehicleRoutingProblem readVrp = vrpToReadBuilder.build();
+
+        Vehicle v = getVehicle("v2", readVrp.getVehicles());
+        Assert.assertEquals("startLoc", v.getStartLocation().getId());
+        Assert.assertEquals("endLoc", v.getEndLocation().getId());
+    }
+
+    @Test
+    public void whenWritingVehicleV2_readingItsLocationsCoordsAgainReturnsCorrectLocationsCoords() {
+        VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance();
+
+        VehicleTypeImpl type1 = VehicleTypeImpl.Builder.newInstance("vehType").addCapacityDimension(0, 20).build();
+        VehicleTypeImpl type2 = VehicleTypeImpl.Builder.newInstance("vehType2").addCapacityDimension(0, 200).build();
+        VehicleImpl v1 = VehicleImpl.Builder.newInstance("v1").setReturnToDepot(false)
+            .setStartLocation(TestUtils.loc("loc")).setType(type1).build();
+        VehicleImpl v2 = VehicleImpl.Builder.newInstance("v2")
+            .setStartLocation(TestUtils.loc("startLoc", Coordinate.newInstance(1, 2)))
+            .setEndLocation(TestUtils.loc("endLoc", Coordinate.newInstance(4, 5))).setType(type2).build();
+
+        builder.addVehicle(v1);
+        builder.addVehicle(v2);
+
+        Service s1 = Service.Builder.newInstance("1").addSizeDimension(0, 1).setLocation(TestUtils.loc("loc")).setServiceTime(2.0).build();
+        Service s2 = Service.Builder.newInstance("2").addSizeDimension(0, 1).setLocation(TestUtils.loc("loc2")).setServiceTime(4.0).build();
+
+        VehicleRoutingProblem vrp = builder.addJob(s1).addJob(s2).build();
+        new VrpXMLWriter(vrp, null).write(infileName);
+
+        VehicleRoutingProblem.Builder vrpToReadBuilder = VehicleRoutingProblem.Builder.newInstance();
+        new VrpXMLReader(vrpToReadBuilder, null).read(infileName);
+        VehicleRoutingProblem readVrp = vrpToReadBuilder.build();
+
+        Vehicle v = getVehicle("v2", readVrp.getVehicles());
+        Assert.assertEquals(1.0, v.getStartLocation().getCoordinate().getX(), 0.01);
+        Assert.assertEquals(2.0, v.getStartLocation().getCoordinate().getY(), 0.01);
+
+        Assert.assertEquals(4.0, v.getEndLocation().getCoordinate().getX(), 0.01);
+        Assert.assertEquals(5.0, v.getEndLocation().getCoordinate().getY(), 0.01);
+    }
+
+    @Test
+    public void whenWritingVehicleWithSeveralCapacityDimensions_itShouldBeWrittenAndRereadCorrectly() {
+        VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance();
+
+        VehicleTypeImpl type2 = VehicleTypeImpl.Builder.newInstance("type")
+            .addCapacityDimension(0, 100)
+            .addCapacityDimension(1, 1000)
+            .addCapacityDimension(2, 10000)
+            .build();
+
+        VehicleImpl v2 = VehicleImpl.Builder.newInstance("v")
+            .setStartLocation(TestUtils.loc("startLoc", Coordinate.newInstance(1, 2)))
+            .setEndLocation(TestUtils.loc("endLoc", Coordinate.newInstance(4, 5))).setType(type2).build();
+        builder.addVehicle(v2);
+
+        VehicleRoutingProblem vrp = builder.build();
+        new VrpXMLWriter(vrp, null).write(infileName);
+
+        VehicleRoutingProblem.Builder vrpToReadBuilder = VehicleRoutingProblem.Builder.newInstance();
+        new VrpXMLReader(vrpToReadBuilder, null).read(infileName);
+        VehicleRoutingProblem readVrp = vrpToReadBuilder.build();
+
+        Vehicle v = getVehicle("v", readVrp.getVehicles());
+        Assert.assertEquals(3, v.getType().getCapacityDimensions().getNuOfDimensions());
+        Assert.assertEquals(100, v.getType().getCapacityDimensions().get(0));
+        Assert.assertEquals(1000, v.getType().getCapacityDimensions().get(1));
+        Assert.assertEquals(10000, v.getType().getCapacityDimensions().get(2));
+    }
+
+    @Test
+    public void whenWritingVehicleWithSeveralCapacityDimensions_itShouldBeWrittenAndRereadCorrectlyV2() {
+        VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance();
+
+        VehicleTypeImpl type2 = VehicleTypeImpl.Builder.newInstance("type")
+            .addCapacityDimension(0, 100)
+            .addCapacityDimension(1, 1000)
+            .addCapacityDimension(10, 10000)
+            .build();
+
+        VehicleImpl v2 = VehicleImpl.Builder.newInstance("v")
+            .setStartLocation(TestUtils.loc("startLoc", Coordinate.newInstance(1, 2)))
+            .setEndLocation(TestUtils.loc("endLoc", Coordinate.newInstance(4, 5))).setType(type2).build();
+        builder.addVehicle(v2);
+
+        VehicleRoutingProblem vrp = builder.build();
+        new VrpXMLWriter(vrp, null).write(infileName);
+
+        VehicleRoutingProblem.Builder vrpToReadBuilder = VehicleRoutingProblem.Builder.newInstance();
+        new VrpXMLReader(vrpToReadBuilder, null).read(infileName);
+        VehicleRoutingProblem readVrp = vrpToReadBuilder.build();
+
+        Vehicle v = getVehicle("v", readVrp.getVehicles());
+        Assert.assertEquals(11, v.getType().getCapacityDimensions().getNuOfDimensions());
+        Assert.assertEquals(0, v.getType().getCapacityDimensions().get(9));
+        Assert.assertEquals(10000, v.getType().getCapacityDimensions().get(10));
+    }
+
+    private Vehicle getVehicle(String string, Collection<Vehicle> vehicles) {
+        for (Vehicle v : vehicles) if (string.equals(v.getId())) return v;
+        return null;
+    }
+
+    @Test
+    public void solutionWithoutUnassignedJobsShouldBeWrittenCorrectly() {
+        VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance();
+
+        VehicleTypeImpl type1 = VehicleTypeImpl.Builder.newInstance("vehType").addCapacityDimension(0, 20).build();
+        VehicleImpl v1 = VehicleImpl.Builder.newInstance("v1").setStartLocation(TestUtils.loc("loc")).setType(type1).build();
+        builder.addVehicle(v1);
+
+        Service s1 = Service.Builder.newInstance("1").addSizeDimension(0, 1).setLocation(TestUtils.loc("loc")).setServiceTime(2.0).build();
+        Service s2 = Service.Builder.newInstance("2").addSizeDimension(0, 1).setLocation(TestUtils.loc("loc2")).setServiceTime(4.0).build();
+
+        VehicleRoutingProblem vrp = builder.addJob(s1).addJob(s2).build();
+
+        VehicleRoute route = VehicleRoute.Builder.newInstance(v1).addService(s1).addService(s2).build();
+        List<VehicleRoute> routes = new ArrayList<VehicleRoute>();
+        routes.add(route);
+        VehicleRoutingProblemSolution solution = new VehicleRoutingProblemSolution(routes, 10.);
+        List<VehicleRoutingProblemSolution> solutions = new ArrayList<VehicleRoutingProblemSolution>();
+        solutions.add(solution);
+
+        new VrpXMLWriter(vrp, solutions).write(infileName);
+
+        VehicleRoutingProblem.Builder vrpToReadBuilder = VehicleRoutingProblem.Builder.newInstance();
+        List<VehicleRoutingProblemSolution> solutionsToRead = new ArrayList<VehicleRoutingProblemSolution>();
+        new VrpXMLReader(vrpToReadBuilder, solutionsToRead).read(infileName);
+
+        assertEquals(1, solutionsToRead.size());
+        Assert.assertEquals(10., Solutions.bestOf(solutionsToRead).getCost(), 0.01);
+        assertTrue(Solutions.bestOf(solutionsToRead).getUnassignedJobs().isEmpty());
+    }
+
+    @Test
+    public void solutionWithUnassignedJobsShouldBeWrittenCorrectly() {
+        VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance();
+
+        VehicleTypeImpl type1 = VehicleTypeImpl.Builder.newInstance("vehType").addCapacityDimension(0, 20).build();
+        VehicleImpl v1 = VehicleImpl.Builder.newInstance("v1").setStartLocation(TestUtils.loc("loc")).setType(type1).build();
+        builder.addVehicle(v1);
+
+        Service s1 = Service.Builder.newInstance("1").addSizeDimension(0, 1).setLocation(TestUtils.loc("loc")).setServiceTime(2.0).build();
+        Service s2 = Service.Builder.newInstance("2").addSizeDimension(0, 1).setLocation(TestUtils.loc("loc2")).setServiceTime(4.0).build();
+
+        VehicleRoutingProblem vrp = builder.addJob(s1).addJob(s2).build();
+
+        VehicleRoute route = VehicleRoute.Builder.newInstance(v1).addService(s1).build();
+        List<VehicleRoute> routes = new ArrayList<VehicleRoute>();
+        routes.add(route);
+        VehicleRoutingProblemSolution solution = new VehicleRoutingProblemSolution(routes, 10.);
+        solution.getUnassignedJobs().add(s2);
+        List<VehicleRoutingProblemSolution> solutions = new ArrayList<VehicleRoutingProblemSolution>();
+        solutions.add(solution);
+
+        new VrpXMLWriter(vrp, solutions).write(infileName);
+
+        VehicleRoutingProblem.Builder vrpToReadBuilder = VehicleRoutingProblem.Builder.newInstance();
+        List<VehicleRoutingProblemSolution> solutionsToRead = new ArrayList<VehicleRoutingProblemSolution>();
+        new VrpXMLReader(vrpToReadBuilder, solutionsToRead).read(infileName);
+
+        assertEquals(1, solutionsToRead.size());
+        Assert.assertEquals(10., Solutions.bestOf(solutionsToRead).getCost(), 0.01);
+        Assert.assertEquals(1, Solutions.bestOf(solutionsToRead).getUnassignedJobs().size());
+        Assert.assertEquals("2", Solutions.bestOf(solutionsToRead).getUnassignedJobs().iterator().next().getId());
+    }
+
+}

jsprit-io/src/test/java/com/graphhopper/jsprit/io/util/TestUtils.java

@@ -0,0 +1,22 @@
+package com.graphhopper.jsprit.io.util;
+
+import com.graphhopper.jsprit.core.problem.Location;
+import com.graphhopper.jsprit.core.util.Coordinate;
+
+/**
+ * Created by schroeder on 19/12/14.
+ */
+public class TestUtils {
+
+    public static Location loc(String id, Coordinate coordinate) {
+        return Location.Builder.newInstance().setId(id).setCoordinate(coordinate).build();
+    }
+
+    public static Location loc(String id) {
+        return Location.Builder.newInstance().setId(id).build();
+    }
+
+    public static Location loc(Coordinate coordinate) {
+        return Location.Builder.newInstance().setCoordinate(coordinate).build();
+    }
+}

jsprit-io/src/test/resources/com/graphhopper/jsprit/io/algorithm/algorithmConfig.xml

@@ -0,0 +1,48 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<algorithm xmlns="http://www.w3schools.com"
+           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+           xsi:schemaLocation="http://www.w3schools.com algorithm_schema.xsd">
+
+    <iterations>2000</iterations>
+
+    <construction>
+        <insertion name="bestInsertion"/>
+    </construction>
+
+    <strategy>
+        <memory>1</memory>
+        <searchStrategies>
+            <searchStrategy name="randomRuinAndRecreate">
+                <selector name="selectBest"/>
+                <acceptor name="acceptNewRemoveWorst"/>
+                <modules>
+                    <module name="ruin_and_recreate">
+                        <ruin name="randomRuin">
+                            <share>0.5</share>
+                        </ruin>
+                        <insertion name="bestInsertion"/>
+                    </module>
+
+                </modules>
+                <probability>0.5</probability>
+            </searchStrategy>
+
+            <searchStrategy name="radialRuinAndRecreate">
+                <selector name="selectBest"/>
+                <acceptor name="acceptNewRemoveWorst"/>
+                <modules>
+                    <module name="ruin_and_recreate">
+                        <ruin name="radialRuin">
+                            <share>0.3</share>
+                        </ruin>
+                        <insertion name="bestInsertion"/>
+                    </module>
+
+                </modules>
+                <probability>0.5</probability>
+            </searchStrategy>
+        </searchStrategies>
+    </strategy>
+
+
+</algorithm>

jsprit-io/src/test/resources/com/graphhopper/jsprit/io/algorithm/algorithmConfigForReaderTest.xml

@@ -0,0 +1,74 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+  ~ 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/>.
+  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-->
+
+<algorithm xmlns="http://www.w3schools.com"
+           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+           xsi:schemaLocation="http://www.w3schools.com algorithm_schema.xsd">
+
+    <maxIterations>2000</maxIterations>
+
+    <terminationCriteria>
+        <termination basedOn="iterations">
+            <iterations>100</iterations>
+        </termination>
+        <termination basedOn="iterations">
+            <iterations>25</iterations>
+        </termination>
+    </terminationCriteria>
+
+    <construction>
+        <insertion name="bestInsertion"/>
+    </construction>
+
+    <strategy>
+        <memory>1</memory>
+        <searchStrategies>
+            <searchStrategy name="randomRuinAndRecreate">
+                <selector name="selectBest"/>
+                <acceptor name="acceptNewRemoveWorst"/>
+                <modules>
+                    <module name="ruin_and_recreate">
+                        <ruin name="randomRuin">
+                            <share>0.5</share>
+                        </ruin>
+                        <insertion name="bestInsertion"/>
+                    </module>
+
+                </modules>
+                <probability>0.5</probability>
+            </searchStrategy>
+
+            <searchStrategy name="radialRuinAndRecreate">
+                <selector name="selectBest"/>
+                <acceptor name="acceptNewRemoveWorst"/>
+                <modules>
+                    <module name="ruin_and_recreate">
+                        <ruin name="radialRuin">
+                            <share>0.3</share>
+                        </ruin>
+                        <insertion name="bestInsertion"/>
+                    </module>
+
+                </modules>
+                <probability>0.5</probability>
+            </searchStrategy>
+        </searchStrategies>
+    </strategy>
+
+
+</algorithm>

jsprit-io/src/test/resources/com/graphhopper/jsprit/io/algorithm/algorithmConfigForReaderTest2.xml

@@ -0,0 +1,70 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+  ~ 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/>.
+  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-->
+
+<algorithm xmlns="http://www.w3schools.com"
+           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+           xsi:schemaLocation="http://www.w3schools.com algorithm_schema.xsd">
+
+    <maxIterations>2000</maxIterations>
+
+    <prematureBreak basedOn="iterations">
+        <iterations>100</iterations>
+    </prematureBreak>
+
+
+    <construction>
+        <insertion name="bestInsertion"/>
+    </construction>
+
+    <strategy>
+        <memory>1</memory>
+        <searchStrategies>
+            <searchStrategy name="randomRuinAndRecreate">
+                <selector name="selectBest"/>
+                <acceptor name="acceptNewRemoveWorst"/>
+                <modules>
+                    <module name="ruin_and_recreate">
+                        <ruin name="randomRuin">
+                            <share>0.5</share>
+                        </ruin>
+                        <insertion name="bestInsertion"/>
+                    </module>
+
+                </modules>
+                <probability>0.5</probability>
+            </searchStrategy>
+
+            <searchStrategy name="radialRuinAndRecreate">
+                <selector name="selectBest"/>
+                <acceptor name="acceptNewRemoveWorst"/>
+                <modules>
+                    <module name="ruin_and_recreate">
+                        <ruin name="radialRuin">
+                            <share>0.3</share>
+                        </ruin>
+                        <insertion name="bestInsertion"/>
+                    </module>
+
+                </modules>
+                <probability>0.5</probability>
+            </searchStrategy>
+        </searchStrategies>
+    </strategy>
+
+
+</algorithm>

jsprit-io/src/test/resources/com/graphhopper/jsprit/io/algorithm/algorithmConfig_withoutIterations.xml

@@ -0,0 +1,48 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<algorithm xmlns="http://www.w3schools.com"
+           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+           xsi:schemaLocation="http://www.w3schools.com algorithm_schema.xsd">
+
+    <construction>
+        <insertion name="bestInsertion"/>
+    </construction>
+
+    <strategy>
+        <memory>1</memory>
+        <searchStrategies>
+
+            <searchStrategy name="randomRuinAndRecreate">
+                <selector name="selectBest"/>
+                <acceptor name="acceptNewRemoveWorst"/>
+                <modules>
+                    <module name="ruin_and_recreate">
+                        <ruin name="randomRuin">
+                            <share>0.5</share>
+                        </ruin>
+                        <insertion name="bestInsertion"/>
+                    </module>
+
+                </modules>
+                <probability>0.5</probability>
+            </searchStrategy>
+
+            <searchStrategy name="radialRuinAndRecreate">
+                <selector name="selectBest"/>
+                <acceptor name="acceptNewRemoveWorst"/>
+                <modules>
+                    <module name="ruin_and_recreate">
+                        <ruin name="radialRuin">
+                            <share>0.3</share>
+                        </ruin>
+                        <insertion name="bestInsertion"/>
+                    </module>
+
+                </modules>
+                <probability>0.5</probability>
+            </searchStrategy>
+
+        </searchStrategies>
+    </strategy>
+
+
+</algorithm>

jsprit-io/src/test/resources/com/graphhopper/jsprit/io/algorithm/finiteVrp.xml

@@ -0,0 +1,88 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<problem xmlns="http://www.w3schools.com"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://www.w3schools.com vrp_xml_schema.xsd">
+    <problemType>
+        <fleetSize>FINITE</fleetSize>
+        <fleetComposition>HETEROGENEOUS</fleetComposition>
+    </problemType>
+
+    <vehicles>
+        <vehicle>
+            <id>v1</id>
+            <location>
+                <id>depotLoc2</id>
+                <coord x="100.0" y="100.0"/>
+            </location>
+            <typeId>vehType</typeId>
+            <timeSchedule>
+                <start>0.0</start>
+                <end>1000.0</end>
+            </timeSchedule>
+        </vehicle>
+        <vehicle>
+            <id>v2</id>
+            <location>
+                <id>depotLoc</id>
+                <coord x="10.0" y="100.0"/>
+            </location>
+            <typeId>vehType2</typeId>
+            <timeSchedule>
+                <start>0.0</start>
+                <end>1000.0</end>
+            </timeSchedule>
+        </vehicle>
+    </vehicles>
+    <vehicleTypes>
+        <type>
+            <id>vehType</id>
+            <capacity>20</capacity>
+            <costs>
+                <fixed>0.0</fixed>
+                <distance>0.0</distance>
+                <time>0.0</time>
+            </costs>
+        </type>
+        <type>
+            <id>vehType2</id>
+            <capacity>200</capacity>
+            <costs>
+                <fixed>0.0</fixed>
+                <distance>0.0</distance>
+                <time>0.0</time>
+            </costs>
+        </type>
+    </vehicleTypes>
+
+    <services>
+        <service id="1" type="service">
+            <locationId>j(1,5)</locationId>
+            <coord x="10.0" y="10.0"/>
+            <capacity-demand>1</capacity-demand>
+            <duration>0.0</duration>
+            <timeWindows>
+                <timeWindow>
+                    <start>0.0</start>
+                    <end>4000.0</end>
+                </timeWindow>
+            </timeWindows>
+        </service>
+
+        <service id="2" type="service">
+            <locationId>i(3,9)</locationId>
+            <coord x="10.0" y="10.0"/>
+            <capacity-demand>1</capacity-demand>
+            <duration>0.0</duration>
+            <timeWindows>
+                <timeWindow>
+                    <start>0.0</start>
+                    <end>4000.0</end>
+                </timeWindow>
+            </timeWindows>
+        </service>
+
+    </services>
+
+
+</problem>

jsprit-io/src/test/resources/com/graphhopper/jsprit/io/algorithm/testConfig.xml

@@ -0,0 +1,70 @@
+<?xml version="1.0" ?>
+
+<config>
+
+    <iterations>10</iterations>
+
+    <construction>
+        <insertion name="bestInsertion"/>
+    </construction>
+
+    <strategy>
+        <memory>1</memory>
+        <searchStrategies>
+            <searchStrategy name="randomRuinAndRecreate">
+                <selector name="selectBest"/>
+                <acceptor name="acceptNewRemoveWorst"/>
+                <modules>
+                    <module name="ruin_and_recreate">
+                        <ruin name="randomRuin">
+                            <share>0.5</share>
+                        </ruin>
+                        <insertion name="bestInsertion"/>
+                    </module>
+                </modules>
+                <probability>0.4</probability>
+            </searchStrategy>
+
+            <searchStrategy name="randomRuinSmall">
+                <selector name="selectBest"/>
+                <acceptor name="acceptNewRemoveWorst"/>
+                <modules>
+                    <module name="ruin_and_recreate">
+                        <ruin name="randomRuin">
+                            <share>0.1</share>
+                        </ruin>
+                        <insertion name="bestInsertion"/>
+                    </module>
+                </modules>
+                <probability>0.4</probability>
+            </searchStrategy>
+
+            <searchStrategy name="radialRuinAndRecreate">
+                <selector name="selectBest"/>
+                <acceptor name="acceptNewRemoveWorst"/>
+                <modules>
+                    <module name="ruin_and_recreate">
+                        <ruin name="radialRuin">
+                            <share>0.3</share>
+                        </ruin>
+                        <insertion name="bestInsertion" id="1"/>
+                    </module>
+                </modules>
+                <probability>0.2</probability>
+            </searchStrategy>
+
+            <!-- 			<searchStrategy id="gendreauPostOpt"> -->
+            <!-- 				<modules number="1"> -->
+            <!-- 					<module name="gendreau"> -->
+            <!-- 						<iterations>200</iterations> -->
+            <!-- 		 				<share>0.2</share> -->
+            <!-- 					</module> -->
+            <!-- 				</modules> -->
+            <!-- 				<probability>0.1</probability> -->
+            <!-- 			</searchStrategy> -->
+        </searchStrategies>
+
+    </strategy>
+
+
+</config>

jsprit-io/src/test/resources/com/graphhopper/jsprit/io/problem/biggerProblem.xml

@@ -0,0 +1,644 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<problem xmlns="http://www.w3schools.com"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://www.w3schools.com vrp_xml_schema.xsd">
+    <problemType>
+        <fleetSize>FINITE</fleetSize>
+        <fleetComposition>HOMOGENEOUS</fleetComposition>
+    </problemType>
+    <vehicles>
+        <vehicle>
+            <id>18</id>
+            <typeId>3.5T</typeId>
+            <startLocation>
+                <id>[x=0.0][y=0.0]</id>
+                <coord x="0.0" y="0.0"/>
+            </startLocation>
+            <endLocation>
+                <id>[x=0.0][y=0.0]</id>
+                <coord x="0.0" y="0.0"/>
+            </endLocation>
+            <timeSchedule>
+                <start>14400.0</start>
+                <end>46800.0</end>
+            </timeSchedule>
+            <returnToDepot>true</returnToDepot>
+        </vehicle>
+        <vehicle>
+            <id>19</id>
+            <typeId>3.5T</typeId>
+            <startLocation>
+                <id>[x=0.0][y=0.0]</id>
+                <coord x="0.0" y="0.0"/>
+            </startLocation>
+            <endLocation>
+                <id>[x=0.0][y=0.0]</id>
+                <coord x="0.0" y="0.0"/>
+            </endLocation>
+            <timeSchedule>
+                <start>39600.0</start>
+                <end>64800.0</end>
+            </timeSchedule>
+            <returnToDepot>true</returnToDepot>
+        </vehicle>
+        <vehicle>
+            <id>20</id>
+            <typeId>3.5T</typeId>
+            <startLocation>
+                <id>[x=0.0][y=0.0]</id>
+                <coord x="0.0" y="0.0"/>
+            </startLocation>
+            <endLocation>
+                <id>[x=0.0][y=0.0]</id>
+                <coord x="0.0" y="0.0"/>
+            </endLocation>
+            <timeSchedule>
+                <start>14400.0</start>
+                <end>46800.0</end>
+            </timeSchedule>
+            <returnToDepot>true</returnToDepot>
+        </vehicle>
+        <vehicle>
+            <id>7</id>
+            <typeId>1.5T</typeId>
+            <startLocation>
+                <id>[x=0.0][y=0.0]</id>
+                <coord x="0.0" y="0.0"/>
+            </startLocation>
+            <endLocation>
+                <id>[x=0.0][y=0.0]</id>
+                <coord x="0.0" y="0.0"/>
+            </endLocation>
+            <timeSchedule>
+                <start>14400.0</start>
+                <end>46800.0</end>
+            </timeSchedule>
+            <returnToDepot>true</returnToDepot>
+        </vehicle>
+        <vehicle>
+            <id>23</id>
+            <typeId>5T</typeId>
+            <startLocation>
+                <id>[x=0.0][y=0.0]</id>
+                <coord x="0.0" y="0.0"/>
+            </startLocation>
+            <endLocation>
+                <id>[x=0.0][y=0.0]</id>
+                <coord x="0.0" y="0.0"/>
+            </endLocation>
+            <timeSchedule>
+                <start>14400.0</start>
+                <end>46800.0</end>
+            </timeSchedule>
+            <returnToDepot>true</returnToDepot>
+        </vehicle>
+        <vehicle>
+            <id>11</id>
+            <typeId>3.5T</typeId>
+            <startLocation>
+                <id>[x=0.0][y=0.0]</id>
+                <coord x="0.0" y="0.0"/>
+            </startLocation>
+            <endLocation>
+                <id>[x=0.0][y=0.0]</id>
+                <coord x="0.0" y="0.0"/>
+            </endLocation>
+            <timeSchedule>
+                <start>14400.0</start>
+                <end>46800.0</end>
+            </timeSchedule>
+            <returnToDepot>true</returnToDepot>
+        </vehicle>
+        <vehicle>
+            <id>3</id>
+            <typeId>1.5T</typeId>
+            <startLocation>
+                <id>[x=0.0][y=0.0]</id>
+                <coord x="0.0" y="0.0"/>
+            </startLocation>
+            <endLocation>
+                <id>[x=0.0][y=0.0]</id>
+                <coord x="0.0" y="0.0"/>
+            </endLocation>
+            <timeSchedule>
+                <start>14400.0</start>
+                <end>46800.0</end>
+            </timeSchedule>
+            <returnToDepot>true</returnToDepot>
+        </vehicle>
+        <vehicle>
+            <id>1</id>
+            <typeId>1.5T</typeId>
+            <startLocation>
+                <id>[x=0.0][y=0.0]</id>
+                <coord x="0.0" y="0.0"/>
+            </startLocation>
+            <endLocation>
+                <id>[x=0.0][y=0.0]</id>
+                <coord x="0.0" y="0.0"/>
+            </endLocation>
+            <timeSchedule>
+                <start>14400.0</start>
+                <end>46800.0</end>
+            </timeSchedule>
+            <returnToDepot>true</returnToDepot>
+        </vehicle>
+        <vehicle>
+            <id>12</id>
+            <typeId>3.5T</typeId>
+            <startLocation>
+                <id>[x=0.0][y=0.0]</id>
+                <coord x="0.0" y="0.0"/>
+            </startLocation>
+            <endLocation>
+                <id>[x=0.0][y=0.0]</id>
+                <coord x="0.0" y="0.0"/>
+            </endLocation>
+            <timeSchedule>
+                <start>14400.0</start>
+                <end>46800.0</end>
+            </timeSchedule>
+            <returnToDepot>true</returnToDepot>
+        </vehicle>
+        <vehicle>
+            <id>22</id>
+            <typeId>5T</typeId>
+            <startLocation>
+                <id>[x=0.0][y=0.0]</id>
+                <coord x="0.0" y="0.0"/>
+            </startLocation>
+            <endLocation>
+                <id>[x=0.0][y=0.0]</id>
+                <coord x="0.0" y="0.0"/>
+            </endLocation>
+            <timeSchedule>
+                <start>14400.0</start>
+                <end>46800.0</end>
+            </timeSchedule>
+            <returnToDepot>true</returnToDepot>
+        </vehicle>
+        <vehicle>
+            <id>15</id>
+            <typeId>3.5T</typeId>
+            <startLocation>
+                <id>[x=0.0][y=0.0]</id>
+                <coord x="0.0" y="0.0"/>
+            </startLocation>
+            <endLocation>
+                <id>[x=0.0][y=0.0]</id>
+                <coord x="0.0" y="0.0"/>
+            </endLocation>
+            <timeSchedule>
+                <start>14400.0</start>
+                <end>46800.0</end>
+            </timeSchedule>
+            <returnToDepot>true</returnToDepot>
+        </vehicle>
+        <vehicle>
+            <id>16</id>
+            <typeId>3.5T</typeId>
+            <startLocation>
+                <id>[x=0.0][y=0.0]</id>
+                <coord x="0.0" y="0.0"/>
+            </startLocation>
+            <endLocation>
+                <id>[x=0.0][y=0.0]</id>
+                <coord x="0.0" y="0.0"/>
+            </endLocation>
+            <timeSchedule>
+                <start>14400.0</start>
+                <end>46800.0</end>
+            </timeSchedule>
+            <returnToDepot>true</returnToDepot>
+        </vehicle>
+        <vehicle>
+            <id>9</id>
+            <typeId>1.5T</typeId>
+            <startLocation>
+                <id>[x=0.0][y=0.0]</id>
+                <coord x="0.0" y="0.0"/>
+            </startLocation>
+            <endLocation>
+                <id>[x=0.0][y=0.0]</id>
+                <coord x="0.0" y="0.0"/>
+            </endLocation>
+            <timeSchedule>
+                <start>14400.0</start>
+                <end>46800.0</end>
+            </timeSchedule>
+            <returnToDepot>true</returnToDepot>
+        </vehicle>
+        <vehicle>
+            <id>4</id>
+            <typeId>1.5T</typeId>
+            <startLocation>
+                <id>[x=0.0][y=0.0]</id>
+                <coord x="0.0" y="0.0"/>
+            </startLocation>
+            <endLocation>
+                <id>[x=0.0][y=0.0]</id>
+                <coord x="0.0" y="0.0"/>
+            </endLocation>
+            <timeSchedule>
+                <start>14400.0</start>
+                <end>46800.0</end>
+            </timeSchedule>
+            <returnToDepot>true</returnToDepot>
+        </vehicle>
+        <vehicle>
+            <id>2</id>
+            <typeId>1.5T</typeId>
+            <startLocation>
+                <id>[x=0.0][y=0.0]</id>
+                <coord x="0.0" y="0.0"/>
+            </startLocation>
+            <endLocation>
+                <id>[x=0.0][y=0.0]</id>
+                <coord x="0.0" y="0.0"/>
+            </endLocation>
+            <timeSchedule>
+                <start>14400.0</start>
+                <end>46800.0</end>
+            </timeSchedule>
+            <returnToDepot>true</returnToDepot>
+        </vehicle>
+        <vehicle>
+            <id>24</id>
+            <typeId>5T</typeId>
+            <startLocation>
+                <id>[x=0.0][y=0.0]</id>
+                <coord x="0.0" y="0.0"/>
+            </startLocation>
+            <endLocation>
+                <id>[x=0.0][y=0.0]</id>
+                <coord x="0.0" y="0.0"/>
+            </endLocation>
+            <timeSchedule>
+                <start>14400.0</start>
+                <end>46800.0</end>
+            </timeSchedule>
+            <returnToDepot>true</returnToDepot>
+        </vehicle>
+        <vehicle>
+            <id>5</id>
+            <typeId>1.5T</typeId>
+            <startLocation>
+                <id>[x=0.0][y=0.0]</id>
+                <coord x="0.0" y="0.0"/>
+            </startLocation>
+            <endLocation>
+                <id>[x=0.0][y=0.0]</id>
+                <coord x="0.0" y="0.0"/>
+            </endLocation>
+            <timeSchedule>
+                <start>14400.0</start>
+                <end>46800.0</end>
+            </timeSchedule>
+            <returnToDepot>true</returnToDepot>
+        </vehicle>
+        <vehicle>
+            <id>17</id>
+            <typeId>3.5T</typeId>
+            <startLocation>
+                <id>[x=0.0][y=0.0]</id>
+                <coord x="0.0" y="0.0"/>
+            </startLocation>
+            <endLocation>
+                <id>[x=0.0][y=0.0]</id>
+                <coord x="0.0" y="0.0"/>
+            </endLocation>
+            <timeSchedule>
+                <start>14400.0</start>
+                <end>46800.0</end>
+            </timeSchedule>
+            <returnToDepot>true</returnToDepot>
+        </vehicle>
+        <vehicle>
+            <id>25</id>
+            <typeId>5T</typeId>
+            <startLocation>
+                <id>[x=0.0][y=0.0]</id>
+                <coord x="0.0" y="0.0"/>
+            </startLocation>
+            <endLocation>
+                <id>[x=0.0][y=0.0]</id>
+                <coord x="0.0" y="0.0"/>
+            </endLocation>
+            <timeSchedule>
+                <start>14400.0</start>
+                <end>46800.0</end>
+            </timeSchedule>
+            <returnToDepot>true</returnToDepot>
+        </vehicle>
+        <vehicle>
+            <id>13</id>
+            <typeId>3.5T</typeId>
+            <startLocation>
+                <id>[x=0.0][y=0.0]</id>
+                <coord x="0.0" y="0.0"/>
+            </startLocation>
+            <endLocation>
+                <id>[x=0.0][y=0.0]</id>
+                <coord x="0.0" y="0.0"/>
+            </endLocation>
+            <timeSchedule>
+                <start>14400.0</start>
+                <end>46800.0</end>
+            </timeSchedule>
+            <returnToDepot>true</returnToDepot>
+        </vehicle>
+        <vehicle>
+            <id>27</id>
+            <typeId>8T</typeId>
+            <startLocation>
+                <id>[x=0.0][y=0.0]</id>
+                <coord x="0.0" y="0.0"/>
+            </startLocation>
+            <endLocation>
+                <id>[x=0.0][y=0.0]</id>
+                <coord x="0.0" y="0.0"/>
+            </endLocation>
+            <timeSchedule>
+                <start>14400.0</start>
+                <end>46800.0</end>
+            </timeSchedule>
+            <returnToDepot>true</returnToDepot>
+        </vehicle>
+        <vehicle>
+            <id>6</id>
+            <typeId>1.5T</typeId>
+            <startLocation>
+                <id>[x=0.0][y=0.0]</id>
+                <coord x="0.0" y="0.0"/>
+            </startLocation>
+            <endLocation>
+                <id>[x=0.0][y=0.0]</id>
+                <coord x="0.0" y="0.0"/>
+            </endLocation>
+            <timeSchedule>
+                <start>14400.0</start>
+                <end>46800.0</end>
+            </timeSchedule>
+            <returnToDepot>true</returnToDepot>
+        </vehicle>
+        <vehicle>
+            <id>10</id>
+            <typeId>1.5T</typeId>
+            <startLocation>
+                <id>[x=0.0][y=0.0]</id>
+                <coord x="0.0" y="0.0"/>
+            </startLocation>
+            <endLocation>
+                <id>[x=0.0][y=0.0]</id>
+                <coord x="0.0" y="0.0"/>
+            </endLocation>
+            <timeSchedule>
+                <start>14400.0</start>
+                <end>46800.0</end>
+            </timeSchedule>
+            <returnToDepot>true</returnToDepot>
+        </vehicle>
+        <vehicle>
+            <id>8</id>
+            <typeId>1.5T</typeId>
+            <startLocation>
+                <id>[x=0.0][y=0.0]</id>
+                <coord x="0.0" y="0.0"/>
+            </startLocation>
+            <endLocation>
+                <id>[x=0.0][y=0.0]</id>
+                <coord x="0.0" y="0.0"/>
+            </endLocation>
+            <timeSchedule>
+                <start>14400.0</start>
+                <end>46800.0</end>
+            </timeSchedule>
+            <returnToDepot>true</returnToDepot>
+        </vehicle>
+        <vehicle>
+            <id>26</id>
+            <typeId>8T</typeId>
+            <startLocation>
+                <id>[x=0.0][y=0.0]</id>
+                <coord x="0.0" y="0.0"/>
+            </startLocation>
+            <endLocation>
+                <id>[x=0.0][y=0.0]</id>
+                <coord x="0.0" y="0.0"/>
+            </endLocation>
+            <timeSchedule>
+                <start>14400.0</start>
+                <end>46800.0</end>
+            </timeSchedule>
+            <returnToDepot>true</returnToDepot>
+        </vehicle>
+        <vehicle>
+            <id>14</id>
+            <typeId>3.5T</typeId>
+            <startLocation>
+                <id>[x=0.0][y=0.0]</id>
+                <coord x="0.0" y="0.0"/>
+            </startLocation>
+            <endLocation>
+                <id>[x=0.0][y=0.0]</id>
+                <coord x="0.0" y="0.0"/>
+            </endLocation>
+            <timeSchedule>
+                <start>14400.0</start>
+                <end>46800.0</end>
+            </timeSchedule>
+            <returnToDepot>true</returnToDepot>
+        </vehicle>
+        <vehicle>
+            <id>21</id>
+            <typeId>5T</typeId>
+            <startLocation>
+                <id>[x=0.0][y=0.0]</id>
+                <coord x="0.0" y="0.0"/>
+            </startLocation>
+            <endLocation>
+                <id>[x=0.0][y=0.0]</id>
+                <coord x="0.0" y="0.0"/>
+            </endLocation>
+            <timeSchedule>
+                <start>14400.0</start>
+                <end>46800.0</end>
+            </timeSchedule>
+            <returnToDepot>true</returnToDepot>
+        </vehicle>
+    </vehicles>
+    <vehicleTypes>
+        <type>
+            <id>1.5T</id>
+            <capacity-dimensions>
+                <dimension index="0">0</dimension>
+            </capacity-dimensions>
+            <costs>
+                <fixed>0.0</fixed>
+                <distance>1.0</distance>
+                <time>0.0</time>
+            </costs>
+        </type>
+        <type>
+            <id>3.5T</id>
+            <capacity-dimensions>
+                <dimension index="0">0</dimension>
+            </capacity-dimensions>
+            <costs>
+                <fixed>0.0</fixed>
+                <distance>1.0</distance>
+                <time>0.0</time>
+            </costs>
+        </type>
+        <type>
+            <id>5T</id>
+            <capacity-dimensions>
+                <dimension index="0">0</dimension>
+            </capacity-dimensions>
+            <costs>
+                <fixed>0.0</fixed>
+                <distance>1.0</distance>
+                <time>0.0</time>
+            </costs>
+        </type>
+        <type>
+            <id>8T</id>
+            <capacity-dimensions>
+                <dimension index="0">0</dimension>
+            </capacity-dimensions>
+            <costs>
+                <fixed>0.0</fixed>
+                <distance>1.0</distance>
+                <time>0.0</time>
+            </costs>
+        </type>
+    </vehicleTypes>
+    <services>
+        <service id="3" type="service">
+            <locationId>[x=1000.0][y=1000.0]</locationId>
+            <coord x="1000.0" y="1000.0"/>
+            <capacity-dimensions>
+                <dimension index="0">0</dimension>
+            </capacity-dimensions>
+            <duration>0.0</duration>
+            <timeWindows>
+                <timeWindow>
+                    <start>21600.0</start>
+                    <end>36000.0</end>
+                </timeWindow>
+            </timeWindows>
+        </service>
+        <service id="2" type="service">
+            <locationId>[x=1000.0][y=1000.0]</locationId>
+            <coord x="1000.0" y="1000.0"/>
+            <capacity-dimensions>
+                <dimension index="0">0</dimension>
+            </capacity-dimensions>
+            <duration>0.0</duration>
+            <timeWindows>
+                <timeWindow>
+                    <start>21600.0</start>
+                    <end>36000.0</end>
+                </timeWindow>
+            </timeWindows>
+        </service>
+        <service id="1" type="service">
+            <locationId>[x=1000.0][y=1000.0]</locationId>
+            <coord x="1000.0" y="1000.0"/>
+            <capacity-dimensions>
+                <dimension index="0">0</dimension>
+            </capacity-dimensions>
+            <duration>0.0</duration>
+            <timeWindows>
+                <timeWindow>
+                    <start>19800.0</start>
+                    <end>21600.0</end>
+                </timeWindow>
+            </timeWindows>
+        </service>
+        <service id="7" type="service">
+            <locationId>[x=1000.0][y=1000.0]</locationId>
+            <coord x="1000.0" y="1000.0"/>
+            <capacity-dimensions>
+                <dimension index="0">0</dimension>
+            </capacity-dimensions>
+            <duration>0.0</duration>
+            <timeWindows>
+                <timeWindow>
+                    <start>21600.0</start>
+                    <end>43200.0</end>
+                </timeWindow>
+            </timeWindows>
+        </service>
+        <service id="6" type="service">
+            <locationId>[x=1000.0][y=1000.0]</locationId>
+            <coord x="1000.0" y="1000.0"/>
+            <capacity-dimensions>
+                <dimension index="0">0</dimension>
+            </capacity-dimensions>
+            <duration>0.0</duration>
+            <timeWindows>
+                <timeWindow>
+                    <start>21600.0</start>
+                    <end>43200.0</end>
+                </timeWindow>
+            </timeWindows>
+        </service>
+        <service id="5" type="service">
+            <locationId>[x=1000.0][y=1000.0]</locationId>
+            <coord x="1000.0" y="1000.0"/>
+            <capacity-dimensions>
+                <dimension index="0">0</dimension>
+            </capacity-dimensions>
+            <duration>0.0</duration>
+            <timeWindows>
+                <timeWindow>
+                    <start>21600.0</start>
+                    <end>36000.0</end>
+                </timeWindow>
+            </timeWindows>
+        </service>
+        <service id="4" type="service">
+            <locationId>[x=1000.0][y=1000.0]</locationId>
+            <coord x="1000.0" y="1000.0"/>
+            <capacity-dimensions>
+                <dimension index="0">0</dimension>
+            </capacity-dimensions>
+            <duration>0.0</duration>
+            <timeWindows>
+                <timeWindow>
+                    <start>21600.0</start>
+                    <end>36000.0</end>
+                </timeWindow>
+            </timeWindows>
+        </service>
+        <service id="9" type="service">
+            <locationId>[x=1000.0][y=1000.0]</locationId>
+            <coord x="1000.0" y="1000.0"/>
+            <capacity-dimensions>
+                <dimension index="0">0</dimension>
+            </capacity-dimensions>
+            <duration>0.0</duration>
+            <timeWindows>
+                <timeWindow>
+                    <start>54000.0</start>
+                    <end>64800.0</end>
+                </timeWindow>
+            </timeWindows>
+        </service>
+        <service id="8" type="service">
+            <locationId>[x=1000.0][y=1000.0]</locationId>
+            <coord x="1000.0" y="1000.0"/>
+            <capacity-dimensions>
+                <dimension index="0">0</dimension>
+            </capacity-dimensions>
+            <duration>0.0</duration>
+            <timeWindows>
+                <timeWindow>
+                    <start>21600.0</start>
+                    <end>50400.0</end>
+                </timeWindow>
+            </timeWindows>
+        </service>
+    </services>
+</problem>

jsprit-io/src/test/resources/com/graphhopper/jsprit/io/problem/finiteVrpForReaderTest.xml

@@ -0,0 +1,237 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<!--~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+  ~ 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/>.
+  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-->
+
+<problem xmlns="http://www.w3schools.com"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://www.w3schools.com vrp_xml_schema.xsd">
+    <problemType>
+        <fleetSize>FINITE</fleetSize>
+        <fleetComposition>HETEROGENEOUS</fleetComposition>
+    </problemType>
+
+    <vehicles>
+        <vehicle>
+            <id>v1</id>
+            <location>
+                <id>depotLoc2</id>
+                <coord x="100.0" y="100.0"/>
+                <index>1</index>
+            </location>
+            <typeId>vehType</typeId>
+            <timeSchedule>
+                <start>0.0</start>
+                <end>1000.0</end>
+            </timeSchedule>
+            <skills>skill1; SKill2</skills>
+        </vehicle>
+        <vehicle>
+            <id>v2</id>
+            <location>
+                <id>depotLoc</id>
+                <coord x="10.0" y="100.0"/>
+                <index>2</index>
+            </location>
+            <returnToDepot>false</returnToDepot>
+            <typeId>vehType2</typeId>
+            <timeSchedule>
+                <start>0.0</start>
+                <end>1000.0</end>
+            </timeSchedule>
+        </vehicle>
+        <vehicle>
+            <id>v3</id>
+            <startLocation>
+                <id>startLoc</id>
+                <coord x="10.0" y="100.0"/>
+                <index>3</index>
+            </startLocation>
+            <endLocation>
+                <id>endLoc</id>
+                <coord x="1000.0" y="2000.0"/>
+                <index>4</index>
+            </endLocation>
+            <typeId>vehType2</typeId>
+            <timeSchedule>
+                <start>0.0</start>
+                <end>1000.0</end>
+            </timeSchedule>
+        </vehicle>
+        <vehicle>
+            <id>v4</id>
+            <location>
+                <id>startLoc</id>
+                <coord x="10.0" y="100.0"/>
+            </location>
+            <endLocation>
+                <id>endLoc</id>
+                <coord x="1000.0" y="2000.0"/>
+            </endLocation>
+            <typeId>vehType2</typeId>
+            <timeSchedule>
+                <start>0.0</start>
+                <end>1000.0</end>
+            </timeSchedule>
+        </vehicle>
+        <vehicle>
+            <id>v5</id>
+            <location>
+                <id>startLoc</id>
+                <coord x="10.0" y="100.0"/>
+            </location>
+            <endLocation>
+                <id>endLoc</id>
+                <coord x="1000.0" y="2000.0"/>
+            </endLocation>
+            <typeId>vehType3</typeId>
+            <timeSchedule>
+                <start>0.0</start>
+                <end>1000.0</end>
+            </timeSchedule>
+        </vehicle>
+    </vehicles>
+    <vehicleTypes>
+        <type>
+            <id>vehType</id>
+            <capacity-dimensions>
+                <dimension index="0">20</dimension>
+            </capacity-dimensions>
+            <costs>
+                <fixed>0.0</fixed>
+                <distance>0.0</distance>
+                <time>0.0</time>
+            </costs>
+        </type>
+        <type>
+            <id>vehType2</id>
+            <capacity>200</capacity>
+            <costs>
+                <fixed>0.0</fixed>
+                <distance>0.0</distance>
+                <time>0.0</time>
+            </costs>
+        </type>
+        <type>
+            <id>vehType3</id>
+            <capacity-dimensions>
+                <dimension index="0">100</dimension>
+                <dimension index="1">1000</dimension>
+                <dimension index="2">10000</dimension>
+                <dimension index="10">100000</dimension>
+            </capacity-dimensions>
+            <costs>
+                <fixed>0.0</fixed>
+                <distance>0.0</distance>
+                <time>0.0</time>
+            </costs>
+        </type>
+    </vehicleTypes>
+
+    <services>
+        <service id="1" type="service">
+            <locationId>j(1,5)</locationId>
+            <name>cleaning</name>
+            <coord x="10.0" y="10.0"/>
+            <capacity-dimensions>
+                <dimension index="0">1</dimension>
+            </capacity-dimensions>
+            <duration>10.0</duration>
+            <timeWindows>
+                <timeWindow>
+                    <start>0.0</start>
+                    <end>4000.0</end>
+                </timeWindow>
+            </timeWindows>
+            <requiredSkills>skill1, Skill2</requiredSkills>
+        </service>
+
+        <service id="2" type="service">
+            <locationId>i(3,9)</locationId>
+            <name>cleaning</name>
+            <coord x="10.0" y="10.0"/>
+            <capacity-demand>1</capacity-demand>
+            <duration>0.0</duration>
+            <timeWindows>
+                <timeWindow>
+                    <start>0.0</start>
+                    <end>4000.0</end>
+                </timeWindow>
+            </timeWindows>
+        </service>
+
+    </services>
+
+    <shipments>
+        <shipment id="3">
+            <name>deliver-smth</name>
+            <pickup>
+                <locationId>i(3,9)</locationId>
+                <coord x="10.0" y="10.0"/>
+                <duration>10.0</duration>
+                <timeWindows>
+                    <timeWindow>
+                        <start>1000.0</start>
+                        <end>4000.0</end>
+                    </timeWindow>
+                </timeWindows>
+            </pickup>
+            <delivery>
+                <locationId>i(9,9)</locationId>
+                <coord x="10.0" y="0.0"/>
+                <duration>100.0</duration>
+                <timeWindows>
+                    <timeWindow>
+                        <start>6000.0</start>
+                        <end>10000.0</end>
+                    </timeWindow>
+                </timeWindows>
+            </delivery>
+            <capacity-dimensions>
+                <dimension index="0">10</dimension>
+            </capacity-dimensions>
+            <requiredSkills>skill1, Skill2</requiredSkills>
+        </shipment>
+
+        <shipment id="4">
+            <pickup>
+                <coord x="10.0" y="10.0"/>
+                <timeWindows>
+                    <timeWindow>
+                        <start>1000.0</start>
+                        <end>4000.0</end>
+                    </timeWindow>
+                </timeWindows>
+            </pickup>
+            <delivery>
+                <coord x="10.0" y="0.0"/>
+                <duration>100.0</duration>
+                <timeWindows>
+                    <timeWindow>
+                        <start>6000.0</start>
+                        <end>10000.0</end>
+                    </timeWindow>
+                </timeWindows>
+            </delivery>
+            <capacity-dimensions>
+                <dimension index="0">10</dimension>
+            </capacity-dimensions>
+            <name>deliver-smth</name>
+        </shipment>
+
+    </shipments>
+</problem>

jsprit-io/src/test/resources/com/graphhopper/jsprit/io/problem/finiteVrpWithInitialSolutionForReaderTest.xml

@@ -0,0 +1,223 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<problem xmlns="http://www.w3schools.com"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://www.w3schools.com vrp_xml_schema.xsd">
+    <problemType>
+        <fleetSize>FINITE</fleetSize>
+        <fleetComposition>HETEROGENEOUS</fleetComposition>
+    </problemType>
+
+    <vehicles>
+        <vehicle>
+            <id>v1</id>
+            <location>
+                <id>depotLoc2</id>
+                <coord x="100.0" y="100.0"/>
+            </location>
+            <typeId>vehType</typeId>
+            <timeSchedule>
+                <start>0.0</start>
+                <end>1000.0</end>
+            </timeSchedule>
+        </vehicle>
+        <vehicle>
+            <id>v2</id>
+            <location>
+                <id>depotLoc</id>
+                <coord x="10.0" y="100.0"/>
+            </location>
+            <returnToDepot>false</returnToDepot>
+            <typeId>vehType2</typeId>
+            <timeSchedule>
+                <start>0.0</start>
+                <end>1000.0</end>
+            </timeSchedule>
+        </vehicle>
+        <vehicle>
+            <id>v3</id>
+            <startLocation>
+                <id>startLoc</id>
+                <coord x="10.0" y="100.0"/>
+            </startLocation>
+            <endLocation>
+                <id>endLoc</id>
+                <coord x="1000.0" y="2000.0"/>
+            </endLocation>
+            <typeId>vehType2</typeId>
+            <timeSchedule>
+                <start>0.0</start>
+                <end>1000.0</end>
+            </timeSchedule>
+        </vehicle>
+        <vehicle>
+            <id>v4</id>
+            <location>
+                <id>startLoc</id>
+                <coord x="10.0" y="100.0"/>
+            </location>
+            <endLocation>
+                <id>endLoc</id>
+                <coord x="1000.0" y="2000.0"/>
+            </endLocation>
+            <typeId>vehType2</typeId>
+            <timeSchedule>
+                <start>0.0</start>
+                <end>1000.0</end>
+            </timeSchedule>
+        </vehicle>
+        <vehicle>
+            <id>v5</id>
+            <location>
+                <id>startLoc</id>
+                <coord x="10.0" y="100.0"/>
+            </location>
+            <endLocation>
+                <id>endLoc</id>
+                <coord x="1000.0" y="2000.0"/>
+            </endLocation>
+            <typeId>vehType3</typeId>
+            <timeSchedule>
+                <start>0.0</start>
+                <end>1000.0</end>
+            </timeSchedule>
+        </vehicle>
+    </vehicles>
+    <vehicleTypes>
+        <type>
+            <id>vehType</id>
+            <capacity-dimensions>
+                <dimension index="0">20</dimension>
+            </capacity-dimensions>
+            <costs>
+                <fixed>0.0</fixed>
+                <distance>0.0</distance>
+                <time>0.0</time>
+            </costs>
+        </type>
+        <type>
+            <id>vehType2</id>
+            <capacity>200</capacity>
+            <costs>
+                <fixed>0.0</fixed>
+                <distance>0.0</distance>
+                <time>0.0</time>
+            </costs>
+        </type>
+        <type>
+            <id>vehType3</id>
+            <capacity-dimensions>
+                <dimension index="0">100</dimension>
+                <dimension index="1">1000</dimension>
+                <dimension index="2">10000</dimension>
+                <dimension index="10">100000</dimension>
+            </capacity-dimensions>
+            <costs>
+                <fixed>0.0</fixed>
+                <distance>0.0</distance>
+                <time>0.0</time>
+            </costs>
+        </type>
+    </vehicleTypes>
+
+    <services>
+        <service id="1" type="service">
+            <locationId>j(1,5)</locationId>
+            <coord x="10.0" y="10.0"/>
+            <capacity-dimensions>
+                <dimension index="0">1</dimension>
+            </capacity-dimensions>
+            <duration>10.0</duration>
+            <timeWindows>
+                <timeWindow>
+                    <start>0.0</start>
+                    <end>4000.0</end>
+                </timeWindow>
+            </timeWindows>
+        </service>
+
+        <service id="2" type="service">
+            <locationId>i(3,9)</locationId>
+            <coord x="10.0" y="10.0"/>
+            <capacity-demand>1</capacity-demand>
+            <duration>0.0</duration>
+            <timeWindows>
+                <timeWindow>
+                    <start>0.0</start>
+                    <end>4000.0</end>
+                </timeWindow>
+            </timeWindows>
+        </service>
+
+    </services>
+
+    <shipments>
+        <shipment id="3">
+            <pickup>
+                <locationId>i(3,9)</locationId>
+                <coord x="10.0" y="10.0"/>
+                <duration>10.0</duration>
+                <timeWindows>
+                    <timeWindow>
+                        <start>1000.0</start>
+                        <end>4000.0</end>
+                    </timeWindow>
+                </timeWindows>
+            </pickup>
+            <delivery>
+                <locationId>i(9,9)</locationId>
+                <coord x="10.0" y="0.0"/>
+                <duration>100.0</duration>
+                <timeWindows>
+                    <timeWindow>
+                        <start>6000.0</start>
+                        <end>10000.0</end>
+                    </timeWindow>
+                </timeWindows>
+            </delivery>
+            <capacity-demand>10</capacity-demand>
+        </shipment>
+
+        <shipment id="4">
+            <pickup>
+                <coord x="10.0" y="10.0"/>
+                <timeWindows>
+                    <timeWindow>
+                        <start>1000.0</start>
+                        <end>4000.0</end>
+                    </timeWindow>
+                </timeWindows>
+            </pickup>
+            <delivery>
+                <coord x="10.0" y="0.0"/>
+                <duration>100.0</duration>
+                <timeWindows>
+                    <timeWindow>
+                        <start>6000.0</start>
+                        <end>10000.0</end>
+                    </timeWindow>
+                </timeWindows>
+            </delivery>
+            <capacity-dimensions>
+                <dimension index="0">10</dimension>
+            </capacity-dimensions>
+        </shipment>
+
+    </shipments>
+
+    <initialRoutes>
+        <route>
+            <driverId>noDriver</driverId>
+            <vehicleId>v1</vehicleId>
+            <start>10.</start>
+            <act type="pickupShipment">
+                <shipmentId>4</shipmentId>
+            </act>
+            <act type="deliverShipment">
+                <shipmentId>4</shipmentId>
+            </act>
+            <end/>
+        </route>
+    </initialRoutes>
+
+</problem>

jsprit-io/src/test/resources/com/graphhopper/jsprit/io/problem/finiteVrpWithShipmentsAndSolution.xml

@@ -0,0 +1,165 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<problem xmlns="http://www.w3schools.com"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://www.w3schools.com vrp_xml_schema.xsd">
+    <problemType>
+        <fleetSize>FINITE</fleetSize>
+        <fleetComposition>HETEROGENEOUS</fleetComposition>
+    </problemType>
+
+    <vehicles>
+        <vehicle>
+            <id>v1</id>
+            <location>
+                <id>depotLoc2</id>
+                <coord x="100.0" y="100.0"/>
+            </location>
+            <typeId>vehType</typeId>
+            <timeSchedule>
+                <start>0.0</start>
+                <end>1000.0</end>
+            </timeSchedule>
+        </vehicle>
+        <vehicle>
+            <id>v2</id>
+            <location>
+                <id>depotLoc</id>
+                <coord x="10.0" y="100.0"/>
+            </location>
+            <typeId>vehType2</typeId>
+            <timeSchedule>
+                <start>0.0</start>
+                <end>1000.0</end>
+            </timeSchedule>
+        </vehicle>
+    </vehicles>
+    <vehicleTypes>
+        <type>
+            <id>vehType</id>
+            <capacity>20</capacity>
+            <costs>
+                <fixed>0.0</fixed>
+                <distance>0.0</distance>
+                <time>0.0</time>
+            </costs>
+        </type>
+        <type>
+            <id>vehType2</id>
+            <capacity>200</capacity>
+            <costs>
+                <fixed>0.0</fixed>
+                <distance>0.0</distance>
+                <time>0.0</time>
+            </costs>
+        </type>
+    </vehicleTypes>
+
+    <services>
+        <service id="1" type="service">
+            <locationId>j(1,5)</locationId>
+            <coord x="10.0" y="10.0"/>
+            <capacity-demand>1</capacity-demand>
+            <duration>0.0</duration>
+            <timeWindows>
+                <timeWindow>
+                    <start>0.0</start>
+                    <end>4000.0</end>
+                </timeWindow>
+            </timeWindows>
+        </service>
+
+        <service id="2" type="service">
+            <locationId>i(3,9)</locationId>
+            <coord x="10.0" y="10.0"/>
+            <capacity-demand>1</capacity-demand>
+            <duration>0.0</duration>
+            <timeWindows>
+                <timeWindow>
+                    <start>0.0</start>
+                    <end>4000.0</end>
+                </timeWindow>
+            </timeWindows>
+        </service>
+
+        <service id="4" type="service">
+            <locationId>i(3,9)</locationId>
+            <coord x="10.0" y="10.0"/>
+            <capacity-demand>1</capacity-demand>
+            <duration>0.0</duration>
+            <timeWindows>
+                <timeWindow>
+                    <start>0.0</start>
+                    <end>4000.0</end>
+                </timeWindow>
+            </timeWindows>
+        </service>
+    </services>
+
+    <shipments>
+        <shipment id="3">
+            <pickup>
+                <locationId>i(3,9)</locationId>
+                <coord x="10.0" y="10.0"/>
+                <duration>0.0</duration>
+                <timeWindows>
+                    <timeWindow>
+                        <start>0.0</start>
+                        <end>4000.0</end>
+                    </timeWindow>
+                </timeWindows>
+            </pickup>
+            <delivery>
+                <locationId>i(9,9)</locationId>
+                <coord x="10.0" y="0.0"/>
+                <duration>0.0</duration>
+                <timeWindows>
+                    <timeWindow>
+                        <start>0.0</start>
+                        <end>4000.0</end>
+                    </timeWindow>
+                </timeWindows>
+            </delivery>
+            <capacity-demand>1</capacity-demand>
+        </shipment>
+    </shipments>
+
+    <solutions>
+        <solution>
+            <cost>100.0</cost>
+            <routes>
+                <route>
+                    <cost>0.0</cost>
+                    <driverId>noDriver</driverId>
+                    <vehicleId>v1</vehicleId>
+                    <start>10.0</start>
+                    <act type="service">
+                        <serviceId>1</serviceId>
+                        <arrTime>20.0</arrTime>
+                        <endTime>30.0</endTime>
+                    </act>
+                    <act type="service">
+                        <serviceId>2</serviceId>
+                        <arrTime>40.0</arrTime>
+                        <endTime>80.0</endTime>
+                    </act>
+                    <act type="pickupShipment">
+                        <shipmentId>3</shipmentId>
+                        <arrTime>40.0</arrTime>
+                        <endTime>80.0</endTime>
+                    </act>
+                    <act type="deliverShipment">
+                        <shipmentId>3</shipmentId>
+                        <arrTime>40.0</arrTime>
+                        <endTime>80.0</endTime>
+                    </act>
+                    <end>100.0</end>
+                </route>
+            </routes>
+            <unassignedJobs>
+                <job id="4"/>
+            </unassignedJobs>
+        </solution>
+    </solutions>
+
+</problem>

jsprit-io/src/test/resources/com/graphhopper/jsprit/io/problem/simpleProblem_inclShipments_iniRoutes.xml

@@ -0,0 +1,132 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<problem xmlns="http://www.w3schools.com"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://www.w3schools.com vrp_xml_schema.xsd">
+    <problemType>
+        <fleetSize>FINITE</fleetSize>
+        <fleetComposition>HOMOGENEOUS</fleetComposition>
+    </problemType>
+    <vehicles>
+        <vehicle>
+            <id>veh1</id>
+            <typeId>type1</typeId>
+            <startLocation>
+                <id>[x=0.0][y=0.0]</id>
+                <coord x="0.0" y="0.0"/>
+            </startLocation>
+            <endLocation>
+                <id>[x=0.0][y=0.0]</id>
+                <coord x="0.0" y="0.0"/>
+            </endLocation>
+            <timeSchedule>
+                <start>0.0</start>
+                <end>46800.0</end>
+            </timeSchedule>
+            <returnToDepot>true</returnToDepot>
+        </vehicle>
+        <vehicle>
+            <id>veh2</id>
+            <typeId>type1</typeId>
+            <startLocation>
+                <id>[x=0.0][y=0.0]</id>
+                <coord x="0.0" y="0.0"/>
+            </startLocation>
+            <endLocation>
+                <id>[x=0.0][y=0.0]</id>
+                <coord x="0.0" y="0.0"/>
+            </endLocation>
+            <timeSchedule>
+                <start>0.0</start>
+                <end>64800.0</end>
+            </timeSchedule>
+            <returnToDepot>true</returnToDepot>
+        </vehicle>
+    </vehicles>
+    <vehicleTypes>
+        <type>
+            <id>type1</id>
+            <capacity-dimensions>
+                <dimension index="0">0</dimension>
+            </capacity-dimensions>
+            <costs>
+                <fixed>0.0</fixed>
+                <distance>1.0</distance>
+                <time>0.0</time>
+            </costs>
+        </type>
+    </vehicleTypes>
+    <services>
+        <service id="2" type="service">
+            <locationId>loc_s2</locationId>
+            <coord x="10.0" y="0.0"/>
+            <capacity-dimensions>
+                <dimension index="0">0</dimension>
+            </capacity-dimensions>
+            <duration>0.0</duration>
+        </service>
+        <service id="1" type="service">
+            <locationId>loc_s1</locationId>
+            <coord x="20.0" y="0.0"/>
+            <capacity-dimensions>
+                <dimension index="0">0</dimension>
+            </capacity-dimensions>
+            <duration>0.0</duration>
+        </service>
+    </services>
+
+    <shipments>
+        <shipment id="3">
+            <pickup>
+                <locationId>loc_pickup_shipment_3</locationId>
+                <coord x="0." y="10.0"/>
+            </pickup>
+            <delivery>
+                <locationId>loc_deliver_shipment_3</locationId>
+                <coord x="0." y="20.0"/>
+            </delivery>
+            <capacity-dimensions>
+                <dimension index="0">0</dimension>
+            </capacity-dimensions>
+        </shipment>
+
+        <shipment id="4">
+            <pickup>
+                <locationId>loc_pickup_shipment_4</locationId>
+                <coord x="0." y="12.0"/>
+            </pickup>
+            <delivery>
+                <locationId>loc_deliver_shipment_4</locationId>
+                <coord x="0." y="18.0"/>
+            </delivery>
+            <capacity-dimensions>
+                <dimension index="0">0</dimension>
+            </capacity-dimensions>
+        </shipment>
+
+    </shipments>
+
+    <initialRoutes>
+        <route>
+            <driverId>noDriver</driverId>
+            <vehicleId>veh1</vehicleId>
+            <start>0.</start>
+            <act type="deliverService">
+                <serviceId>1</serviceId>
+            </act>
+            <end/>
+        </route>
+
+        <route>
+            <driverId>noDriver</driverId>
+            <vehicleId>veh2</vehicleId>
+            <start>0.</start>
+            <act type="pickupShipment">
+                <shipmentId>3</shipmentId>
+            </act>
+            <act type="deliverShipment">
+                <shipmentId>3</shipmentId>
+            </act>
+            <end/>
+        </route>
+    </initialRoutes>
+</problem>

jsprit-io/src/test/resources/com/graphhopper/jsprit/io/problem/simpleProblem_iniRoutes.xml

@@ -0,0 +1,88 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<problem xmlns="http://www.w3schools.com"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://www.w3schools.com vrp_xml_schema.xsd">
+    <problemType>
+        <fleetSize>FINITE</fleetSize>
+        <fleetComposition>HOMOGENEOUS</fleetComposition>
+    </problemType>
+    <vehicles>
+        <vehicle>
+            <id>veh1</id>
+            <typeId>type1</typeId>
+            <startLocation>
+                <id>[x=0.0][y=0.0]</id>
+                <coord x="0.0" y="0.0"/>
+            </startLocation>
+            <endLocation>
+                <id>[x=0.0][y=0.0]</id>
+                <coord x="0.0" y="0.0"/>
+            </endLocation>
+            <timeSchedule>
+                <start>0.0</start>
+                <end>46800.0</end>
+            </timeSchedule>
+            <returnToDepot>true</returnToDepot>
+        </vehicle>
+        <vehicle>
+            <id>2</id>
+            <typeId>type1</typeId>
+            <startLocation>
+                <id>[x=0.0][y=0.0]</id>
+                <coord x="0.0" y="0.0"/>
+            </startLocation>
+            <endLocation>
+                <id>[x=0.0][y=0.0]</id>
+                <coord x="0.0" y="0.0"/>
+            </endLocation>
+            <timeSchedule>
+                <start>0.0</start>
+                <end>64800.0</end>
+            </timeSchedule>
+            <returnToDepot>true</returnToDepot>
+        </vehicle>
+    </vehicles>
+    <vehicleTypes>
+        <type>
+            <id>type1</id>
+            <capacity-dimensions>
+                <dimension index="0">0</dimension>
+            </capacity-dimensions>
+            <costs>
+                <fixed>0.0</fixed>
+                <distance>1.0</distance>
+                <time>0.0</time>
+            </costs>
+        </type>
+    </vehicleTypes>
+    <services>
+        <service id="2" type="service">
+            <locationId>loc_s2</locationId>
+            <coord x="1000.0" y="0.0"/>
+            <capacity-dimensions>
+                <dimension index="0">0</dimension>
+            </capacity-dimensions>
+            <duration>0.0</duration>
+        </service>
+        <service id="1" type="service">
+            <locationId>loc_s3</locationId>
+            <coord x="1000.0" y="1000.0"/>
+            <capacity-dimensions>
+                <dimension index="0">0</dimension>
+            </capacity-dimensions>
+            <duration>0.0</duration>
+        </service>
+    </services>
+    <initialRoutes>
+        <route>
+            <driverId>noDriver</driverId>
+            <vehicleId>veh1</vehicleId>
+            <start>0.</start>
+            <act type="deliverService">
+                <serviceId>1</serviceId>
+            </act>
+            <end/>
+        </route>
+
+    </initialRoutes>
+</problem>

jsprit-io/src/test/resources/com/graphhopper/jsprit/io/problem/simpleProblem_iniRoutes_2.xml

@@ -0,0 +1,87 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<problem xmlns="http://www.w3schools.com"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://www.w3schools.com vrp_xml_schema.xsd">
+    <problemType>
+        <fleetSize>FINITE</fleetSize>
+        <fleetComposition>HOMOGENEOUS</fleetComposition>
+    </problemType>
+    <vehicles>
+        <vehicle>
+            <id>veh1</id>
+            <typeId>type1</typeId>
+            <startLocation>
+                <id>[x=0.0][y=0.0]</id>
+                <coord x="0.0" y="0.0"/>
+            </startLocation>
+            <endLocation>
+                <id>[x=0.0][y=0.0]</id>
+                <coord x="0.0" y="0.0"/>
+            </endLocation>
+            <timeSchedule>
+                <start>0.0</start>
+                <end>46800.0</end>
+            </timeSchedule>
+            <returnToDepot>true</returnToDepot>
+        </vehicle>
+    </vehicles>
+    <vehicleTypes>
+        <type>
+            <id>type1</id>
+            <capacity-dimensions>
+                <dimension index="0">100</dimension>
+            </capacity-dimensions>
+            <costs>
+                <fixed>0.0</fixed>
+                <distance>1.0</distance>
+                <time>0.0</time>
+            </costs>
+        </type>
+    </vehicleTypes>
+
+    <shipments>
+        <shipment id="3">
+            <pickup>
+                <locationId>loc_pickup_shipment_3</locationId>
+                <coord x="0." y="10.0"/>
+            </pickup>
+            <delivery>
+                <locationId>loc_deliver_shipment_3</locationId>
+                <coord x="0." y="20.0"/>
+            </delivery>
+            <capacity-dimensions>
+                <dimension index="0">100</dimension>
+            </capacity-dimensions>
+        </shipment>
+
+        <shipment id="4">
+            <pickup>
+                <locationId>loc_pickup_shipment_4</locationId>
+                <coord x="0." y="12.0"/>
+            </pickup>
+            <delivery>
+                <locationId>loc_deliver_shipment_4</locationId>
+                <coord x="0." y="18.0"/>
+            </delivery>
+            <capacity-dimensions>
+                <dimension index="0">50</dimension>
+            </capacity-dimensions>
+        </shipment>
+
+    </shipments>
+
+    <initialRoutes>
+        <route>
+            <driverId>noDriver</driverId>
+            <vehicleId>veh1</vehicleId>
+            <start>0.</start>
+            <act type="pickupShipment">
+                <shipmentId>3</shipmentId>
+            </act>
+            <act type="deliverShipment">
+                <shipmentId>3</shipmentId>
+            </act>
+            <end/>
+        </route>
+    </initialRoutes>
+</problem>

jsprit-io/src/test/resources/com/graphhopper/jsprit/io/problem/simpleProblem_iniRoutes_3.xml

@@ -0,0 +1,80 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<problem xmlns="http://www.w3schools.com"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://www.w3schools.com vrp_xml_schema.xsd">
+    <problemType>
+        <fleetSize>FINITE</fleetSize>
+        <fleetComposition>HOMOGENEOUS</fleetComposition>
+    </problemType>
+    <vehicles>
+        <vehicle>
+            <id>veh1</id>
+            <typeId>type1</typeId>
+            <startLocation>
+                <id>[x=5000.0][y=5000.0]</id>
+                <coord x="5000.0" y="5000.0"/>
+            </startLocation>
+            <timeSchedule>
+                <start>0.0</start>
+                <end>46800.0</end>
+            </timeSchedule>
+            <returnToDepot>true</returnToDepot>
+        </vehicle>
+        <vehicle>
+            <id>veh2</id>
+            <typeId>type1</typeId>
+            <startLocation>
+                <id>[x=0.0][y=0.0]</id>
+                <coord x="0.0" y="0.0"/>
+            </startLocation>
+            <timeSchedule>
+                <start>0.0</start>
+                <end>64800.0</end>
+            </timeSchedule>
+            <returnToDepot>true</returnToDepot>
+        </vehicle>
+    </vehicles>
+    <vehicleTypes>
+        <type>
+            <id>type1</id>
+            <capacity-dimensions>
+                <dimension index="0">0</dimension>
+            </capacity-dimensions>
+            <costs>
+                <fixed>0.0</fixed>
+                <distance>1.0</distance>
+                <time>0.0</time>
+            </costs>
+        </type>
+    </vehicleTypes>
+    <services>
+        <service id="2" type="service">
+            <locationId>loc_s2</locationId>
+            <coord x="1000.0" y="0.0"/>
+            <capacity-dimensions>
+                <dimension index="0">0</dimension>
+            </capacity-dimensions>
+            <duration>0.0</duration>
+        </service>
+        <service id="1" type="service">
+            <locationId>loc_s3</locationId>
+            <coord x="1000.0" y="1000.0"/>
+            <capacity-dimensions>
+                <dimension index="0">0</dimension>
+            </capacity-dimensions>
+            <duration>0.0</duration>
+        </service>
+    </services>
+    <initialRoutes>
+        <route>
+            <driverId>noDriver</driverId>
+            <vehicleId>veh1</vehicleId>
+            <start>0.</start>
+            <act type="deliverService">
+                <serviceId>1</serviceId>
+            </act>
+            <end/>
+        </route>
+
+    </initialRoutes>
+</problem>