@wemap/geo 3.2.17 → 4.0.0

package/src/graph/Itinerary.spec.js

@@ -0,0 +1,809 @@
+/* eslint-disable max-statements */
+import chai from 'chai';
+
+import { diffAngle } from '@wemap/maths';
+
+import Coordinates from '../coordinates/Coordinates.js';
+import Level from '../coordinates/Level.js';
+
+import Itinerary from './Itinerary.js';
+import Edge from './Edge.js';
+import Node from './Node.js';
+
+import * as CommonTest from '../../tests/CommonTest.js';
+
+const { expect } = chai;
+
+const isReadable = itinerary => {
+    for (let i = 0; i < itinerary.nodes.length; i++) {
+        const node = itinerary.nodes[i];
+        if (i !== itinerary.nodes.length - 1) {
+            const reversed = itinerary._edgesDirectionReversed[i];
+            const firstNode = reversed ? itinerary.edges[i].node2 : itinerary.edges[i].node1;
+            const secondNode = reversed ? itinerary.edges[i].node1 : itinerary.edges[i].node2;
+            expect(firstNode).equal(node);
+            expect(secondNode).equal(itinerary.nodes[i + 1]);
+        }
+    }
+};
+
+const verifyNextEdgesAndNodes = itinerary => {
+
+    let currentNode, currentEdge;
+
+    // Iterate on nodes
+    currentNode = itinerary.nodes[0];
+    for (let i = 0; i < itinerary.nodes.length - 1; i++) {
+        currentEdge = itinerary.getNextEdge(currentNode);
+        expect(itinerary.edges.indexOf(currentEdge)).equal(i);
+
+        currentNode = itinerary.getNextNode(currentNode);
+        expect(itinerary.nodes.indexOf(currentNode)).equal(i + 1);
+    }
+    expect(itinerary.getNextNode(currentNode)).is.null;
+    expect(itinerary.getNextEdge(currentNode)).is.null;
+
+    // Iterate on edges
+    currentEdge = itinerary.edges[0] || null;
+    for (let i = 0; i < itinerary.edges.length - 1; i++) {
+        currentNode = itinerary.getNextNode(currentEdge);
+        expect(itinerary.nodes.indexOf(currentNode)).equal(i + 1);
+
+        currentEdge = itinerary.getNextEdge(currentEdge);
+        expect(itinerary.edges.indexOf(currentEdge)).equal(i + 1);
+    }
+    if (currentEdge !== null) {
+        const lastNode = itinerary.getNextNode(currentEdge);
+        expect(lastNode).is.not.null;
+        expect(itinerary.getNextNode(lastNode)).is.null;
+    }
+    expect(itinerary.getNextEdge(currentEdge)).is.null;
+};
+
+const verifySteps = itinerary => {
+
+    const {
+        steps, nodes, edges, _nextStepsIndexes
+    } = itinerary;
+
+    let previousNodeIndex = 0;
+    let previousEdgeIndex = -1;
+    steps.forEach(step => {
+        let isFirstNode = true;
+        step.nodes.forEach(node => {
+            const currentNodeIndex = nodes.indexOf(node);
+            expect(currentNodeIndex).not.equal(-1);
+            if (isFirstNode) {
+                isFirstNode = false;
+            } else {
+                previousNodeIndex++;
+            }
+            expect(currentNodeIndex).equal(previousNodeIndex);
+        });
+
+        step.edges.forEach(edge => {
+            const currentEdgeIndex = edges.indexOf(edge);
+            expect(currentEdgeIndex).not.equal(-1);
+            expect(currentEdgeIndex).equal(previousEdgeIndex + 1);
+            previousEdgeIndex++;
+        });
+        expect(step.location).equal(step.nodes[0].coords);
+    });
+
+    expect(_nextStepsIndexes.length).equal(nodes.length);
+
+    for (let i = 0; i < nodes.length; i++) {
+        const node = nodes[i];
+        const nextStep = itinerary.getNextStep(node);
+        const nextStepId = itinerary.steps.indexOf(nextStep);
+        const previousStep = itinerary.getPreviousStep(node);
+        const previousStepId = itinerary.steps.indexOf(previousStep);
+
+        expect(nextStepId - previousStepId).equal(1);
+
+        if (nextStepId !== 0) {
+            const currentStep = steps[nextStepId - 1];
+            expect(currentStep.nodes).include(node);
+        } else {
+            expect(nextStep.nodes[0]).equal(node);
+        }
+
+        if (previousStepId !== -1) {
+            const lastPreviousStepNode = previousStep.nodes[previousStep.nodes.length - 1];
+            expect(lastPreviousStepNode).equal(nextStep.nodes[0]);
+        } else {
+            expect(node).equal(nodes[0]);
+        }
+    }
+
+    for (let i = 0; i < edges.length; i++) {
+        const edge = edges[i];
+        const nextStep = itinerary.getNextStep(edge);
+        const nextStepId = itinerary.steps.indexOf(nextStep);
+        const previousStep = itinerary.getPreviousStep(edge);
+        const previousStepId = itinerary.steps.indexOf(previousStep);
+
+        expect(nextStepId - previousStepId).equal(1);
+
+        if (nextStepId !== 0) {
+            const currentStep = steps[nextStepId - 1];
+            expect(currentStep.edges).include(edge);
+        } else {
+            expect(nextStep.edges[0]).equal(edge);
+        }
+
+        if (previousStepId === -1) {
+            expect(edge).equal(edges[0]);
+        }
+    }
+};
+
+
+const verifyItineraryLength = itinerary => {
+    expect(itinerary.length).equals(
+        itinerary.edges.reduce((acc, edge) => acc + edge.length, 0)
+    );
+};
+
+describe('Itinerary', () => {
+
+    const nodes = [
+        new Node(new Coordinates(43.6091194, 3.884099), 'p0'),
+        new Node(new Coordinates(43.6093629, 3.8842777), 'p1'),
+        new Node(new Coordinates(43.6092785, 3.8845052), 'p2')
+    ];
+
+    const edges = [
+        new Edge(nodes[0], nodes[1], null, 'e0'),
+        new Edge(nodes[1], nodes[2], null, 'e1')
+    ];
+
+    const itinerary = new Itinerary(nodes, edges);
+    itinerary.start = new Coordinates(43.6091367, 3.8839298);
+    itinerary.end = new Coordinates(43.6093154, 3.8846326);
+
+    const fakeNode = new Node(new Coordinates(0, 0));
+    const fakeEdge = new Edge(fakeNode, nodes[2]);
+
+    it('readable', () => {
+        isReadable(itinerary);
+    });
+
+    it('length', () => {
+        verifyItineraryLength(itinerary);
+    });
+
+    it('next edge and next node', () => {
+        verifyNextEdgesAndNodes(itinerary);
+
+        expect(itinerary.getEdgeAt(0)).equal(edges[0]);
+        expect(itinerary.getEdgeAt(10)).equal(edges[0]);
+        expect(itinerary.getEdgeAt(40)).equal(edges[1]);
+        expect(itinerary.getEdgeAt(80)).is.null;
+
+        expect(itinerary.getNextNode()).is.null;
+        expect(itinerary.getNextNode(fakeNode)).is.null;
+        expect(itinerary.getNextNode(fakeEdge)).is.null;
+
+        expect(itinerary.getNextEdge()).is.null;
+        expect(itinerary.getNextEdge(fakeNode)).is.null;
+        expect(itinerary.getNextEdge(fakeEdge)).is.null;
+    });
+
+    it('steps', () => {
+        verifySteps(itinerary);
+
+        const { steps } = itinerary;
+        expect(steps.length).equal(3);
+        expect(steps[0].nodes[0]).equal(nodes[0]);
+        expect(steps[0].node.name).equal('p0');
+        expect(steps[0].length).closeTo(30.69, 0.01);
+        expect(steps[0].nodes[1]).equal(nodes[1]);
+        expect(steps[1].nodes[0]).equal(nodes[1]);
+        expect(steps[1].nodes[1]).equal(nodes[2]);
+        expect(steps[2].nodes[0]).equal(nodes[2]);
+
+        expect(itinerary.getNextStep(null)).is.null;
+        expect(itinerary.getNextStep(fakeNode)).is.null;
+        expect(itinerary.getNextStep(fakeEdge)).is.null;
+
+        expect(itinerary.getPreviousStep(null)).is.null;
+        expect(itinerary.getPreviousStep(fakeNode)).is.null;
+        expect(itinerary.getPreviousStep(fakeEdge)).is.null;
+    });
+
+
+    it('info', () => {
+        let itineraryInfo;
+
+        expect(itinerary.getInfo()).is.null;
+        expect(itinerary.getInfo(null)).is.null;
+        expect(itinerary.getInfo({
+            lat: 0,
+            lng: 0
+        })).is.null;
+        expect(itinerary.getInfo(new Coordinates(0, 0, null, new Level(0)))).is.null;
+
+        itineraryInfo = itinerary.getInfo(new Coordinates(43.6091367, 3.8839298));
+        expect(itineraryInfo.projection).is.not.null;
+        expect(itineraryInfo.projection.nearestElement).equal(nodes[0]);
+        expect(itineraryInfo.remainingDistance).be.closeTo(51.30, 0.01);
+        expect(itineraryInfo.traveledDistance).be.closeTo(0, 0.01);
+        expect(itineraryInfo.remainingPercentage).be.closeTo(1.0, 0.01);
+        expect(itineraryInfo.traveledPercentage).be.closeTo(0.0, 0.01);
+        expect(itineraryInfo.previousStep).is.null;
+        expect(itineraryInfo.nextStep).equal(itinerary.steps[0]);
+
+        itineraryInfo = itinerary.getInfo(new Coordinates(43.6091678, 3.884182));
+        expect(itineraryInfo.projection).is.not.null;
+        expect(itineraryInfo.projection.nearestElement).equal(edges[0]);
+        expect(itineraryInfo.remainingDistance).be.closeTo(43.40, 0.01);
+        expect(itineraryInfo.traveledDistance).be.closeTo(7.90, 0.01);
+        expect(itineraryInfo.remainingPercentage).be.closeTo(0.85, 0.01);
+        expect(itineraryInfo.traveledPercentage).be.closeTo(0.15, 0.01);
+        expect(itineraryInfo.previousStep).equal(itinerary.steps[0]);
+        expect(itineraryInfo.nextStep).equal(itinerary.steps[1]);
+
+        itineraryInfo = itinerary.getInfo(new Coordinates(43.6094183, 3.8842195));
+        expect(itineraryInfo.projection).is.not.null;
+        expect(itineraryInfo.projection.nearestElement).equal(nodes[1]);
+        expect(itineraryInfo.previousStep).equal(itinerary.steps[0]);
+        expect(itineraryInfo.nextStep).equal(itinerary.steps[1]);
+
+        itineraryInfo = itinerary.getInfo(new Coordinates(43.6093795, 3.8843617));
+        expect(itineraryInfo.projection).is.not.null;
+        expect(itineraryInfo.projection.nearestElement).equal(edges[1]);
+        expect(itineraryInfo.previousStep).equal(itinerary.steps[1]);
+        expect(itineraryInfo.nextStep).equal(itinerary.steps[2]);
+
+        itineraryInfo = itinerary.getInfo(new Coordinates(43.6093154, 3.8846326));
+        expect(itineraryInfo.projection).is.not.null;
+        expect(itineraryInfo.projection.nearestElement).equal(nodes[2]);
+        expect(itineraryInfo.remainingDistance).be.closeTo(0.0, 0.01);
+        expect(itineraryInfo.traveledDistance).be.closeTo(51.30, 0.01);
+        expect(itineraryInfo.remainingPercentage).be.closeTo(0.0, 0.01);
+        expect(itineraryInfo.traveledPercentage).be.closeTo(1.0, 0.01);
+        expect(itineraryInfo.previousStep).equal(itinerary.steps[1]);
+        expect(itineraryInfo.nextStep).equal(itinerary.steps[2]);
+    });
+
+});
+
+describe('Itinerary single line', () => {
+
+    const nodes = [
+        new Node(new Coordinates(43.6091194, 3.884099), 'p0'),
+        new Node(new Coordinates(43.6093629, 3.8842777), 'p1'),
+        new Node(new Coordinates(43.6094902, 3.8843416), 'p2')
+    ];
+
+    const edges = [
+        new Edge(nodes[0], nodes[1], null, 'e0'),
+        new Edge(nodes[1], nodes[2], null, 'e1')
+    ];
+
+    const itinerary = new Itinerary(nodes, edges);
+    itinerary.start = new Coordinates(43.6091367, 3.8839298);
+    itinerary.end = new Coordinates(43.6095552, 3.8844971);
+
+
+    it('common', () => {
+        isReadable(itinerary);
+        verifyItineraryLength(itinerary);
+        verifyNextEdgesAndNodes(itinerary);
+        verifySteps(itinerary);
+    });
+
+    it('specific', () => {
+        const { steps } = itinerary;
+        expect(steps.length).equal(2);
+        expect(steps[0].nodes[0]).equal(nodes[0]);
+        expect(steps[0].nodes[1]).equal(nodes[1]);
+        expect(steps[0].nodes[2]).equal(nodes[2]);
+        expect(steps[1].nodes[0]).equal(nodes[2]);
+    });
+
+});
+
+
+describe('Itinerary single line - start merged', () => {
+
+    const nodes = [
+        new Node(new Coordinates(43.6091194, 3.884099), 'p0'),
+        new Node(new Coordinates(43.6093629, 3.8842777), 'p1'),
+        new Node(new Coordinates(43.6094902, 3.8843416), 'p2')
+    ];
+
+    const edges = [
+        new Edge(nodes[0], nodes[1], null, 'e0'),
+        new Edge(nodes[1], nodes[2], null, 'e1')
+    ];
+
+    const itinerary = new Itinerary(nodes, edges);
+    itinerary.start = new Coordinates(43.6091194, 3.884099);
+    itinerary.end = new Coordinates(43.6095552, 3.8844971);
+
+
+    it('common', () => {
+        isReadable(itinerary);
+        verifyItineraryLength(itinerary);
+        verifyNextEdgesAndNodes(itinerary);
+        verifySteps(itinerary);
+    });
+
+    it('specific', () => {
+        const { steps } = itinerary;
+        expect(steps.length).equal(2);
+        expect(steps[0].nodes[0]).equal(nodes[0]);
+        expect(steps[0].nodes[1]).equal(nodes[1]);
+        expect(steps[0].nodes[2]).equal(nodes[2]);
+        expect(steps[1].nodes[0]).equal(nodes[2]);
+    });
+
+});
+
+describe('Itinerary single line - end merged', () => {
+
+    const nodes = [
+        new Node(new Coordinates(43.6091194, 3.884099), 'p0'),
+        new Node(new Coordinates(43.6093629, 3.8842777), 'p1'),
+        new Node(new Coordinates(43.6094902, 3.8843416), 'p2')
+    ];
+
+    const edges = [
+        new Edge(nodes[0], nodes[1], null, 'e0'),
+        new Edge(nodes[1], nodes[2], null, 'e1')
+    ];
+
+    const itinerary = new Itinerary(nodes, edges);
+    itinerary.start = new Coordinates(43.6091367, 3.8839298);
+    itinerary.end = new Coordinates(43.6094902, 3.8843416);
+
+
+    it('common', () => {
+        isReadable(itinerary);
+        verifyItineraryLength(itinerary);
+        verifyNextEdgesAndNodes(itinerary);
+        verifySteps(itinerary);
+    });
+
+    it('specific', () => {
+        const { steps } = itinerary;
+        expect(steps.length).equal(2);
+        expect(steps[0].nodes[0]).equal(nodes[0]);
+        expect(steps[0].nodes[1]).equal(nodes[1]);
+        expect(steps[0].nodes[2]).equal(nodes[2]);
+    });
+
+});
+
+
+describe('Itinerary single line - start and end merged', () => {
+
+    const nodes = [
+        new Node(new Coordinates(43.6091194, 3.884099), 'p0'),
+        new Node(new Coordinates(43.6093629, 3.8842777), 'p1')
+    ];
+
+    const edges = [
+        new Edge(nodes[0], nodes[1], null, 'e0')
+    ];
+
+    const itinerary = new Itinerary(nodes, edges);
+    itinerary.start = new Coordinates(43.6091194, 3.884099);
+    itinerary.end = new Coordinates(3.6093629, 3.8842777);
+
+
+    it('common', () => {
+        isReadable(itinerary);
+        verifyItineraryLength(itinerary);
+        verifyNextEdgesAndNodes(itinerary);
+        verifySteps(itinerary);
+    });
+
+    it('specific', () => {
+        const { steps } = itinerary;
+        expect(steps.length).equal(2);
+        expect(steps[0].nodes[0]).equal(nodes[0]);
+        expect(steps[0].nodes[1]).equal(nodes[1]);
+    });
+
+});
+
+describe('Itinerary single point', () => {
+
+    const nodes = [
+        new Node(new Coordinates(43.6092785, 3.8845052), 'p0')
+    ];
+    const itinerary = new Itinerary(nodes, []);
+    itinerary.start = new Coordinates(43.6093154, 3.8846326);
+    itinerary.end = new Coordinates(43.6091901, 3.8845266);
+
+    it('common', () => {
+        isReadable(itinerary);
+        verifyItineraryLength(itinerary);
+        verifyNextEdgesAndNodes(itinerary);
+        verifySteps(itinerary);
+    });
+
+    it('specific', () => {
+        const { steps } = itinerary;
+        expect(steps.length).equal(1);
+        expect(steps[0].nodes[0]).equal(nodes[0]);
+    });
+
+});
+
+describe('Itinerary single point - start and end merged', () => {
+
+    const nodes = [
+        new Node(new Coordinates(43.6092785, 3.8845052), 'p0')
+    ];
+    const itinerary = new Itinerary(nodes, []);
+    itinerary.start = new Coordinates(43.6092785, 3.8845052);
+    itinerary.end = new Coordinates(43.6092785, 3.8845052);
+
+    it('common', () => {
+        isReadable(itinerary);
+        verifyItineraryLength(itinerary);
+        verifyNextEdgesAndNodes(itinerary);
+        verifySteps(itinerary);
+    });
+
+    it('specific', () => {
+        const { steps } = itinerary;
+        expect(steps.length).equal(1);
+        expect(steps[0].nodes[0]).equal(nodes[0]);
+    });
+
+});
+
+
+describe('Itinerary fromOrderedPointsArray', () => {
+
+    const points = [
+        [43.6091194, 3.884099],
+        [43.6093629, 3.8842777],
+        [43.6094902, 3.8843416]
+    ];
+
+    const start = [43.6091367, 3.8839298];
+    const end = [43.6094902, 3.8843416];
+    let itinerary;
+
+    it('common', () => {
+        itinerary = Itinerary.fromOrderedPointsArray(points, start, end);
+
+        isReadable(itinerary);
+        verifyItineraryLength(itinerary);
+        verifyNextEdgesAndNodes(itinerary);
+        verifySteps(itinerary);
+    });
+
+    it('specific', () => {
+        const { nodes } = itinerary;
+        for (let i = 0; i < nodes.length; i++) {
+            expect(Coordinates.equalsTo(nodes[i].coords, points[i]));
+        }
+    });
+
+});
+
+
+describe('Multi - Level Itinerary (down)', () => {
+
+    const nodes = [
+        new Node(new Coordinates(43.6091194, 3.884099, null, new Level(1)), 'p0'),
+        new Node(new Coordinates(43.6093629, 3.8842777, null, new Level(1)), 'p1'),
+        new Node(new Coordinates(43.6094654, 3.8842167, null, new Level(0, 1)), 'p2'),
+        new Node(new Coordinates(43.6094902, 3.8843416, null, new Level(0)), 'p3'),
+        new Node(new Coordinates(43.6095463, 3.8843837, null, new Level(0)), 'p4')
+    ];
+
+    const edges = [
+        new Edge(nodes[0], nodes[1], new Level(1), 'e0'),
+        new Edge(nodes[1], nodes[2], new Level(0, 1), 'e1'),
+        new Edge(nodes[2], nodes[3], new Level(0, 1), 'e2'),
+        new Edge(nodes[3], nodes[4], new Level(0), 'e3')
+    ];
+
+    const itinerary = new Itinerary(nodes, edges);
+    itinerary.start = new Coordinates(43.6091367, 3.8839298, null, new Level(1));
+    itinerary.end = new Coordinates(43.6095552, 3.8844971, null, new Level(0));
+
+    it('common', () => {
+        isReadable(itinerary);
+        verifyItineraryLength(itinerary);
+        verifyNextEdgesAndNodes(itinerary);
+        verifySteps(itinerary);
+    });
+
+    it('specific', () => {
+        const { steps } = itinerary;
+        expect(steps.length).equal(4);
+        expect(steps[0].levelChange).is.null;
+        expect(steps[0].nodes[0]).equal(nodes[0]);
+        expect(steps[0].nodes[1]).equal(nodes[1]);
+
+        expect(steps[1].nodes[0]).equal(nodes[1]);
+        expect(steps[1].levelChange).is.not.null;
+        expect(steps[1].levelChange.direction).equal('down');
+        expect(steps[1].levelChange.diff).equal(-1);
+        expect(steps[1].nodes[1]).equal(nodes[2]);
+        expect(steps[1].nodes[2]).equal(nodes[3]);
+
+        expect(steps[2].levelChange).is.null;
+        expect(steps[2].nodes[0]).equal(nodes[3]);
+        expect(steps[2].nodes[1]).equal(nodes[4]);
+        expect(steps[3].nodes[0]).equal(nodes[4]);
+    });
+
+});
+
+
+describe('Multi - Level Itinerary (up)', () => {
+
+    const nodes = [
+        new Node(new Coordinates(43.6091194, 3.884099, null, new Level(0)), 'p0'),
+        new Node(new Coordinates(43.6093629, 3.8842777, null, new Level(0)), 'p1'),
+        new Node(new Coordinates(43.6094654, 3.8842167, null, new Level(0, 1)), 'p2'),
+        new Node(new Coordinates(43.6094902, 3.8843416, null, new Level(1)), 'p3'),
+        new Node(new Coordinates(43.6095463, 3.8843837, null, new Level(1)), 'p4')
+    ];
+
+    const edges = [
+        new Edge(nodes[0], nodes[1], new Level(0), 'e0'),
+        new Edge(nodes[1], nodes[2], new Level(0, 1), 'e1'),
+        new Edge(nodes[2], nodes[3], new Level(0, 1), 'e2'),
+        new Edge(nodes[3], nodes[4], new Level(1), 'e3')
+    ];
+
+    const itinerary = new Itinerary(nodes, edges);
+    itinerary.start = new Coordinates(43.6091367, 3.8839298, null, new Level(0));
+    itinerary.end = new Coordinates(43.6095552, 3.8844971, null, new Level(1));
+
+    it('common', () => {
+        isReadable(itinerary);
+        verifyItineraryLength(itinerary);
+        verifyNextEdgesAndNodes(itinerary);
+        verifySteps(itinerary);
+    });
+
+    it('specific', () => {
+        const { steps } = itinerary;
+        expect(steps.length).equal(4);
+        expect(steps[0].levelChange).is.null;
+        expect(steps[0].nodes[0]).equal(nodes[0]);
+        expect(steps[0].nodes[1]).equal(nodes[1]);
+
+        expect(steps[1].nodes[0]).equal(nodes[1]);
+        expect(steps[1].levelChange).is.not.null;
+        expect(steps[1].levelChange.direction).equal('up');
+        expect(steps[1].levelChange.diff).equal(1);
+        expect(steps[1].nodes[1]).equal(nodes[2]);
+        expect(steps[1].nodes[2]).equal(nodes[3]);
+
+        expect(steps[2].levelChange).is.null;
+        expect(steps[2].nodes[0]).equal(nodes[3]);
+        expect(steps[2].nodes[1]).equal(nodes[4]);
+        expect(steps[3].nodes[0]).equal(nodes[4]);
+    });
+
+});
+
+
+describe('Multi - Level Itinerary complex', () => {
+
+    const nodes = [
+        new Node(new Coordinates(43.6091194, 3.884099, null, new Level(0)), 'p0'),
+        new Node(new Coordinates(43.6093629, 3.8842777, null, new Level(0)), 'p1'),
+        new Node(new Coordinates(43.6094654, 3.8842167, null, new Level(0, 1)), 'p2'),
+        new Node(new Coordinates(43.6094902, 3.8843416, null, new Level(1)), 'p3'),
+        new Node(new Coordinates(43.6095463, 3.8843837, null, new Level(1)), 'p4'),
+        new Node(new Coordinates(43.6095552, 3.8844971, null, new Level(2)), 'p5'),
+        new Node(new Coordinates(43.6095908, 3.8844662, null, new Level(1)), 'p6'),
+        new Node(new Coordinates(43.6096412, 3.8844706, null, new Level(1)), 'p7')
+    ];
+
+    const edges = [
+        new Edge(nodes[0], nodes[1], new Level(0), 'e0'),
+        new Edge(nodes[1], nodes[2], new Level(0), 'e1'),
+        new Edge(nodes[2], nodes[3], new Level(1), 'e2'),
+        new Edge(nodes[3], nodes[4], new Level(1), 'e3'),
+        new Edge(nodes[4], nodes[5], new Level(1, 2), 'e4'),
+        new Edge(nodes[5], nodes[6], new Level(1, 2), 'e5'),
+        new Edge(nodes[6], nodes[7], new Level(1), 'e6')
+    ];
+
+    const itinerary = new Itinerary(nodes, edges);
+    itinerary.start = new Coordinates(43.6091367, 3.8839298, null, new Level(0));
+    itinerary.end = new Coordinates(43.6096683, 3.884472, null, new Level(1));
+
+    it('common', () => {
+        isReadable(itinerary);
+        verifyItineraryLength(itinerary);
+        verifyNextEdgesAndNodes(itinerary);
+        verifySteps(itinerary);
+    });
+
+    it('getEdgesAtLevel useMultiLevelSegments=false', () => {
+
+        const edgesAtLevel0 = itinerary.getEdgesAtLevel(new Level(0), false);
+        expect(edgesAtLevel0.length).equals(2);
+        expect(edgesAtLevel0[0].name).equals('e0');
+        expect(edgesAtLevel0[1].name).equals('e1');
+
+        const segmentsAtLevel1 = itinerary.getEdgesAtLevel(new Level(1), false);
+        expect(segmentsAtLevel1.length).equals(3);
+        expect(segmentsAtLevel1[0].name).equals('e2');
+        expect(segmentsAtLevel1[1].name).equals('e3');
+        expect(segmentsAtLevel1[2].name).equals('e6');
+
+        const segmentsAtLevel2 = itinerary.getEdgesAtLevel(new Level(2), false);
+        expect(segmentsAtLevel2.length).equals(0);
+
+        const edgesAtLevel01 = itinerary.getEdgesAtLevel(new Level(0, 1), false);
+        expect(edgesAtLevel01.length).equals(5);
+
+        const edgesAtLevel12 = itinerary.getEdgesAtLevel(new Level(1, 2), false);
+        expect(edgesAtLevel12.length).equals(5);
+
+        const edgesAtLevel02 = itinerary.getEdgesAtLevel(new Level(0, 2), false);
+        expect(edgesAtLevel02.length).equals(7);
+
+    });
+
+});
+
+
+describe('Multi - Level Itinerary elevator', () => {
+
+    const start = CommonTest.network.getNodeByName('p17');
+    const end = CommonTest.network.getNodeByName('p18');
+    const itinerary = Itinerary.fromNetworkNodes([
+        start,
+        CommonTest.network.getNodeByName('p19a'),
+        CommonTest.network.getNodeByName('p19b'),
+        end
+    ], start.coords, end.coords);
+
+    it('common', () => {
+        isReadable(itinerary);
+        verifyItineraryLength(itinerary);
+        verifyNextEdgesAndNodes(itinerary);
+        verifySteps(itinerary);
+    });
+
+    it('Verify steps next bearing', () => {
+
+        const testEdgeBearing = (bearing, edgeId) => {
+            expect(diffAngle(
+                bearing,
+                itinerary.edges[edgeId].bearing
+                + (itinerary._edgesDirectionReversed[edgeId] ? Math.PI : 0)
+            )).equal(0);
+        };
+
+        const steps = itinerary.steps;
+        expect(steps[0].previousBearing).equal(0);
+        testEdgeBearing(steps[0].nextBearing, 0);
+
+        testEdgeBearing(steps[1].previousBearing, 0);
+        testEdgeBearing(steps[1].nextBearing, 1);
+
+        testEdgeBearing(steps[2].previousBearing, 1);
+        testEdgeBearing(steps[2].nextBearing, 2);
+
+        testEdgeBearing(steps[3].previousBearing, 2);
+        expect(steps[3].nextBearing).is.undefined;
+
+    });
+});
+
+describe('Itinerary append', () => {
+
+    const points = [
+        [0, 0],
+        [1, 0],
+        [2, 0],
+        [3, 0],
+        [4, 0]
+    ];
+
+    it('first it. end does not equal second it. start', () => {
+
+        const itinerary = Itinerary.fromOrderedPointsArray([
+            points[0], points[1]
+        ], points[0], points[1]);
+
+        const itinerary2 = Itinerary.fromOrderedPointsArray([
+            points[2], points[3], points[4]
+        ], points[2], points[4]);
+
+        expect(() => itinerary.append(itinerary2)).throw(Error);
+
+    });
+
+
+    it('first it. end node equals second it. first node', () => {
+
+        const itinerary = Itinerary.fromOrderedPointsArray([
+            points[0], points[1], points[2]
+        ], points[0], points[2]);
+
+        const itinerary2 = Itinerary.fromOrderedPointsArray([
+            points[2], points[3], points[4]
+        ], points[2], points[4]);
+
+        itinerary.append(itinerary2);
+
+        isReadable(itinerary);
+        verifyItineraryLength(itinerary);
+        verifyNextEdgesAndNodes(itinerary);
+        verifySteps(itinerary);
+
+        expect(itinerary.nodes.length).equals(5);
+    });
+
+    it('last node and end of the first it. are merged', () => {
+
+        const itinerary = Itinerary.fromOrderedPointsArray([
+            points[0], points[1], points[2]
+        ], points[0], points[2]);
+
+        const itinerary2 = Itinerary.fromOrderedPointsArray([
+            points[3], points[4]
+        ], points[2], points[4]);
+
+        itinerary.append(itinerary2);
+
+        isReadable(itinerary);
+        verifyItineraryLength(itinerary);
+        verifyNextEdgesAndNodes(itinerary);
+        verifySteps(itinerary);
+
+        expect(itinerary.nodes.length).equals(5);
+    });
+
+    it('first node and start of the second it. are merged', () => {
+
+        const itinerary = Itinerary.fromOrderedPointsArray([
+            points[0], points[1]
+        ], points[0], points[2]);
+
+        const itinerary2 = Itinerary.fromOrderedPointsArray([
+            points[2], points[3], points[4]
+        ], points[2], points[4]);
+
+        itinerary.append(itinerary2);
+
+        isReadable(itinerary);
+        verifyItineraryLength(itinerary);
+        verifyNextEdgesAndNodes(itinerary);
+        verifySteps(itinerary);
+
+        expect(itinerary.nodes.length).equals(5);
+    });
+
+
+    it('normal', () => {
+
+        const itinerary = Itinerary.fromOrderedPointsArray([
+            points[0], points[1]
+        ], points[0], points[2]);
+
+        const itinerary2 = Itinerary.fromOrderedPointsArray([
+            points[3], points[4]
+        ], points[2], points[4]);
+
+        itinerary.append(itinerary2);
+
+        isReadable(itinerary);
+        verifyItineraryLength(itinerary);
+        verifyNextEdgesAndNodes(itinerary);
+        verifySteps(itinerary);
+
+        expect(itinerary.nodes.length).equals(5);
+    });
+
+});