@Test
  public void testFindShortcuts_Roundabout() {
    LevelGraphStorage g = (LevelGraphStorage) createGraph();
    EdgeSkipIterator iter1_1 = g.edge(1, 3, 1, true);
    EdgeSkipIterator iter1_2 = g.edge(3, 4, 1, true);
    EdgeSkipIterator iter2_1 = g.edge(4, 5, 1, false);
    EdgeSkipIterator iter2_2 = g.edge(5, 6, 1, false);
    EdgeSkipIterator iter3_1 = g.edge(6, 7, 1, true);
    EdgeSkipIterator iter3_2 = g.edge(6, 8, 2, false);
    g.edge(8, 4, 1, false);
    g.setLevel(3, 3);
    g.setLevel(5, 5);
    g.setLevel(7, 7);
    g.setLevel(8, 8);

    PrepareContractionHierarchies prepare = new PrepareContractionHierarchies().graph(g);
    g.edge(1, 4, 2, prepare.scBothDir()).skippedEdges(iter1_1.edge(), iter1_2.edge());
    int f = prepare.scOneDir();
    g.edge(4, 6, 2, f).skippedEdges(iter2_1.edge(), iter2_2.edge());
    g.edge(6, 4, 3, f).skippedEdges(iter3_1.edge(), iter3_2.edge());

    prepare.initFromGraph();
    // there should be two different shortcuts for both directions!
    Collection<Shortcut> sc = prepare.testFindShortcuts(4);
    assertEquals(2, sc.size());
  }
 @Test
 public void testMoreComplexGraph() {
   LevelGraph g = initShortcutsGraph(createGraph());
   int old = g.getAllEdges().maxId();
   PrepareContractionHierarchies prepare = new PrepareContractionHierarchies().graph(g);
   prepare.doWork();
   assertEquals(old + 8, g.getAllEdges().maxId());
 }
 @Test
 public void testAddShortcuts() {
   LevelGraph g = createExampleGraph();
   int old = g.getAllEdges().maxId();
   PrepareContractionHierarchies prepare = new PrepareContractionHierarchies().graph(g);
   prepare.doWork();
   assertEquals(old, g.getAllEdges().maxId());
 }
  @Override
  public PrepareContractionHierarchies prepareGraph(Graph g, FlagEncoder encoder, Weighting w) {
    PrepareContractionHierarchies ch = new PrepareContractionHierarchies(encoder, w).setGraph(g);
    // hack: prepare matrixgraph only once
    if (g != preparedMatrixGraph) ch.doWork();

    return ch;
  }
 @Test
 public void testUnpackingOrder_Fastest() {
   LevelGraphStorage g = (LevelGraphStorage) createGraph();
   PrepareContractionHierarchies prepare = new PrepareContractionHierarchies().graph(g);
   WeightCalculation calc = new FastestCalc(carEncoder);
   initUnpackingGraph(g, calc);
   RoutingAlgorithm algo = prepare.type(calc).vehicle(carEncoder).createAlgo();
   Path p = algo.calcPath(10, 6);
   assertEquals(7, p.distance(), 1e-1);
   assertEquals(Helper.createTList(10, 0, 1, 2, 3, 4, 5, 6), p.calcNodes());
 }
 @Test
 public void testRoundaboutUnpacking() {
   LevelGraph g = createGraph();
   initRoundaboutGraph(g);
   int old = g.getAllEdges().maxId();
   PrepareContractionHierarchies prepare = new PrepareContractionHierarchies().graph(g);
   prepare.doWork();
   assertEquals(old + 25, g.getAllEdges().maxId());
   RoutingAlgorithm algo = prepare.createAlgo();
   Path p = algo.calcPath(4, 7);
   assertEquals(Helper.createTList(4, 5, 6, 7), p.calcNodes());
 }
 @Test
 public void testCircleBug() {
   LevelGraph g = createGraph();
   //  /--1
   // -0--/
   //  |
   g.edge(0, 1, 10, true);
   g.edge(0, 1, 4, true);
   g.edge(0, 2, 10, true);
   g.edge(0, 3, 10, true);
   PrepareContractionHierarchies prepare = new PrepareContractionHierarchies().graph(g);
   prepare.doWork();
   assertEquals(0, prepare.shortcuts());
 }
 @Override
 public RoutingAlgorithmFactory createFactory(
     GraphHopperStorage ghStorage, AlgorithmOptions opts) {
   PrepareContractionHierarchies ch =
       new PrepareContractionHierarchies(
           new GHDirectory("", DAType.RAM_INT),
           ghStorage,
           getGraph(ghStorage, opts.getWeighting()),
           opts.getFlagEncoder(),
           opts.getWeighting(),
           TraversalMode.NODE_BASED);
   ch.doWork();
   return ch;
 }
  @Test
  public void testDirectedGraph2() {
    LevelGraph g = createGraph();
    initDirected2(g);
    int old = GHUtility.count(g.getAllEdges());
    PrepareContractionHierarchies prepare = new PrepareContractionHierarchies().graph(g);
    prepare.doWork();
    // PrepareTowerNodesShortcutsTest.printEdges(g);
    assertEquals(old + 15, GHUtility.count(g.getAllEdges()));
    RoutingAlgorithm algo = prepare.createAlgo();

    Path p = algo.calcPath(0, 10);
    assertEquals(10, p.distance(), 1e-6);
    assertEquals(Helper.createTList(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10), p.calcNodes());
  }
 @Test
 public void testDirectedGraph() {
   LevelGraph g = createGraph();
   g.edge(5, 4, 3, false);
   g.edge(4, 5, 10, false);
   g.edge(2, 4, 1, false);
   g.edge(5, 2, 1, false);
   g.edge(3, 5, 1, false);
   g.edge(4, 3, 1, false);
   int old = GHUtility.count(g.getAllEdges());
   PrepareContractionHierarchies prepare = new PrepareContractionHierarchies().graph(g);
   prepare.doWork();
   // PrepareTowerNodesShortcutsTest.printEdges(g);
   assertEquals(old + 3, GHUtility.count(g.getAllEdges()));
   RoutingAlgorithm algo = prepare.createAlgo();
   Path p = algo.calcPath(4, 2);
   assertEquals(3, p.distance(), 1e-6);
   assertEquals(Helper.createTList(4, 3, 5, 2), p.calcNodes());
 }
  @Test
  public void testDirectedGraph3() {
    LevelGraph g = createGraph();
    g.edge(0, 2, 2, true);
    g.edge(10, 2, 2, true);
    g.edge(11, 2, 2, true);
    // create a longer one directional edge => no longish one-dir shortcut should be created
    g.edge(2, 1, 2, true);
    g.edge(2, 1, 10, false);

    g.edge(1, 3, 2, true);
    g.edge(3, 4, 2, true);
    g.edge(3, 5, 2, true);
    g.edge(3, 6, 2, true);
    g.edge(3, 7, 2, true);

    PrepareContractionHierarchies prepare = new PrepareContractionHierarchies().graph(g);
    prepare.initFromGraph();
    // find all shortcuts if we contract node 1
    Collection<Shortcut> scs = prepare.testFindShortcuts(1);
    assertEquals(2, scs.size());
    Iterator<Shortcut> iter = scs.iterator();
    Shortcut sc1 = iter.next();
    Shortcut sc2 = iter.next();
    if (sc1.distance > sc2.distance) {
      Shortcut tmp = sc1;
      sc1 = sc2;
      sc2 = tmp;
    }

    assertTrue(sc1.toString(), sc1.from == 2 && sc1.to == 3);
    assertTrue(sc2.toString(), sc2.from == 2 && sc2.to == 3);

    assertEquals(sc1.toString(), 4, sc1.distance, 1e-4);
    assertEquals(sc2.toString(), 12, sc2.distance, 1e-4);
  }