@Test
  public void testDozendEdges() {
    graph = createGraph();
    graph.edge(1, 2, 12, true);
    assertEquals(1, count(carAllExplorer.setBaseNode(1)));

    graph.edge(1, 3, 13, false);
    assertEquals(2, count(carAllExplorer.setBaseNode(1)));

    graph.edge(1, 4, 14, false);
    assertEquals(3, count(carAllExplorer.setBaseNode(1)));

    graph.edge(1, 5, 15, false);
    assertEquals(4, count(carAllExplorer.setBaseNode(1)));

    graph.edge(1, 6, 16, false);
    assertEquals(5, count(carAllExplorer.setBaseNode(1)));

    graph.edge(1, 7, 16, false);
    assertEquals(6, count(carAllExplorer.setBaseNode(1)));

    graph.edge(1, 8, 16, false);
    assertEquals(7, count(carAllExplorer.setBaseNode(1)));

    graph.edge(1, 9, 16, false);
    assertEquals(8, count(carAllExplorer.setBaseNode(1)));
    assertEquals(8, count(carOutExplorer.setBaseNode(1)));

    assertEquals(1, count(carInExplorer.setBaseNode(1)));
    assertEquals(1, count(carInExplorer.setBaseNode(2)));
  }
  @Test
  public void internalDisconnect() {
    GraphHopperStorage storage = createGHStorage();
    BaseGraph graph = (BaseGraph) storage.getGraph(Graph.class);
    EdgeIteratorState iter0 = graph.edge(0, 1, 10, true);
    EdgeIteratorState iter2 = graph.edge(1, 2, 10, true);
    EdgeIteratorState iter3 = graph.edge(0, 3, 10, true);

    EdgeExplorer explorer = graph.createEdgeExplorer();

    assertEquals(GHUtility.asSet(3, 1), GHUtility.getNeighbors(explorer.setBaseNode(0)));
    assertEquals(GHUtility.asSet(2, 0), GHUtility.getNeighbors(explorer.setBaseNode(1)));
    // remove edge "1-2" but only from 1 not from 2
    graph.edgeAccess.internalEdgeDisconnect(
        iter2.getEdge(), -1, iter2.getBaseNode(), iter2.getAdjNode());
    assertEquals(GHUtility.asSet(0), GHUtility.getNeighbors(explorer.setBaseNode(1)));
    assertEquals(GHUtility.asSet(1), GHUtility.getNeighbors(explorer.setBaseNode(2)));
    // let 0 unchanged -> no side effects
    assertEquals(GHUtility.asSet(3, 1), GHUtility.getNeighbors(explorer.setBaseNode(0)));

    // remove edge "0-1" but only from 0
    graph.edgeAccess.internalEdgeDisconnect(
        iter0.getEdge(),
        (long) iter3.getEdge() * graph.edgeEntryBytes,
        iter0.getBaseNode(),
        iter0.getAdjNode());
    assertEquals(GHUtility.asSet(3), GHUtility.getNeighbors(explorer.setBaseNode(0)));
    assertEquals(GHUtility.asSet(0), GHUtility.getNeighbors(explorer.setBaseNode(3)));
    assertEquals(GHUtility.asSet(0), GHUtility.getNeighbors(explorer.setBaseNode(1)));
    storage.close();
  }
  @Test
  public void testSimpleDelete3() {
    graph = createGraph();
    NodeAccess na = graph.getNodeAccess();
    na.setNode(7, 7, 1);
    na.setNode(8, 8, 1);
    na.setNode(9, 9, 1);
    na.setNode(11, 11, 1);

    // mini subnetwork which gets completely removed:
    graph.edge(5, 10, 510, true);
    graph.markNodeRemoved(3);
    graph.markNodeRemoved(4);
    graph.markNodeRemoved(5);
    graph.markNodeRemoved(10);

    graph.edge(9, 11, 911, true);
    graph.edge(7, 9, 78, true);
    graph.edge(8, 9, 89, true);

    // perform deletion
    graph.optimize();

    assertEquals(Arrays.<String>asList(), GHUtility.getProblems(graph));

    assertEquals(3, GHUtility.count(carAllExplorer.setBaseNode(getIdOf(graph, 9))));
    assertEquals(1, GHUtility.count(carAllExplorer.setBaseNode(getIdOf(graph, 7))));
    assertEquals(1, GHUtility.count(carAllExplorer.setBaseNode(getIdOf(graph, 8))));
    assertEquals(1, GHUtility.count(carAllExplorer.setBaseNode(getIdOf(graph, 11))));
  }
  @Test
  public void testCheckFirstNode() {
    graph = createGraph();

    assertEquals(0, count(carAllExplorer.setBaseNode(1)));
    graph.edge(0, 1, 12, true);
    assertEquals(1, count(carAllExplorer.setBaseNode(1)));
  }
  @Test
  public void testCreateLocation() {
    graph = createGraph();
    graph.edge(3, 1, 50, true);
    assertEquals(1, count(carOutExplorer.setBaseNode(1)));

    graph.edge(1, 2, 100, true);
    assertEquals(2, count(carOutExplorer.setBaseNode(1)));
  }
  public void testDeleteNodes(int fillToSize) {
    graph = createGraph();
    NodeAccess na = graph.getNodeAccess();
    na.setNode(0, 12, 23);
    na.setNode(1, 38.33f, 135.3f);
    na.setNode(2, 3, 3);
    na.setNode(3, 78, 89);
    na.setNode(4, 2, 1);
    na.setNode(5, 2.5f, 1);

    int deleted = 2;
    for (int i = 6; i < fillToSize; i++) {
      na.setNode(i, i * 1.5, i * 1.6);
      if (i % 3 == 0) {
        graph.markNodeRemoved(i);
        deleted++;
      } else {
        // connect to
        // ... a deleted node
        graph.edge(i, 0, 10 * i, true);
        // ... a non-deleted and non-moved node
        graph.edge(i, 2, 10 * i, true);
        // ... a moved node
        graph.edge(i, fillToSize - 1, 10 * i, true);
      }
    }

    graph.edge(0, 1, 10, true);
    graph.edge(0, 3, 20, false);
    graph.edge(3, 5, 20, true);
    graph.edge(1, 5, 20, false);

    graph.markNodeRemoved(0);
    graph.markNodeRemoved(2);
    // no deletion happend
    assertEquals(fillToSize, graph.getNodes());

    assertEquals(Arrays.<String>asList(), GHUtility.getProblems(graph));

    // now actually perform deletion
    graph.optimize();

    assertEquals(Arrays.<String>asList(), GHUtility.getProblems(graph));

    assertEquals(fillToSize - deleted, graph.getNodes());
    int id1 = getIdOf(graph, 38.33f);
    assertEquals(135.3f, na.getLongitude(id1), 1e-4);
    assertTrue(containsLatitude(graph, carAllExplorer.setBaseNode(id1), 2.5));
    assertFalse(containsLatitude(graph, carAllExplorer.setBaseNode(id1), 12));

    int id3 = getIdOf(graph, 78);
    assertEquals(89, na.getLongitude(id3), 1e-4);
    assertTrue(containsLatitude(graph, carAllExplorer.setBaseNode(id3), 2.5));
    assertFalse(containsLatitude(graph, carAllExplorer.setBaseNode(id3), 12));
  }
  @Test
  public void testEdges() {
    graph = createGraph();
    graph.edge(2, 1, 12, true);
    assertEquals(1, count(carOutExplorer.setBaseNode(2)));

    graph.edge(2, 3, 12, true);
    assertEquals(1, count(carOutExplorer.setBaseNode(1)));
    assertEquals(2, count(carOutExplorer.setBaseNode(2)));
    assertEquals(1, count(carOutExplorer.setBaseNode(3)));
  }
  @Test
  public void testDeleteNodeForUnidir() {
    graph = createGraph();
    NodeAccess na = graph.getNodeAccess();
    na.setNode(10, 10, 1);
    na.setNode(6, 6, 1);
    na.setNode(20, 20, 1);
    na.setNode(21, 21, 1);

    graph.edge(10, 20, 10, false);
    graph.edge(21, 6, 10, false);

    graph.markNodeRemoved(0);
    graph.markNodeRemoved(7);
    assertEquals(22, graph.getNodes());
    graph.optimize();
    assertEquals(20, graph.getNodes());

    assertEquals(1, GHUtility.count(carInExplorer.setBaseNode(getIdOf(graph, 20))));
    assertEquals(0, GHUtility.count(carOutExplorer.setBaseNode(getIdOf(graph, 20))));

    assertEquals(1, GHUtility.count(carOutExplorer.setBaseNode(getIdOf(graph, 10))));
    assertEquals(0, GHUtility.count(carInExplorer.setBaseNode(getIdOf(graph, 10))));

    assertEquals(1, GHUtility.count(carInExplorer.setBaseNode(getIdOf(graph, 6))));
    assertEquals(0, GHUtility.count(carOutExplorer.setBaseNode(getIdOf(graph, 6))));

    assertEquals(1, GHUtility.count(carOutExplorer.setBaseNode(getIdOf(graph, 21))));
    assertEquals(0, GHUtility.count(carInExplorer.setBaseNode(getIdOf(graph, 21))));
  }
  @Test
  public void testUnidirectionalEdgeFilter() {
    graph = createGraph();

    graph.edge(1, 2, 12, false);
    graph.edge(1, 11, 12, false);
    graph.edge(11, 1, 12, false);
    graph.edge(1, 12, 12, false);
    graph.edge(3, 2, 112, false);
    EdgeIterator i = carOutExplorer.setBaseNode(2);
    assertFalse(i.next());

    assertEquals(4, GHUtility.count(carAllExplorer.setBaseNode(1)));

    assertEquals(1, GHUtility.count(carInExplorer.setBaseNode(1)));
    assertEquals(2, GHUtility.count(carInExplorer.setBaseNode(2)));
    assertEquals(0, GHUtility.count(carInExplorer.setBaseNode(3)));

    assertEquals(3, GHUtility.count(carOutExplorer.setBaseNode(1)));
    assertEquals(0, GHUtility.count(carOutExplorer.setBaseNode(2)));
    assertEquals(1, GHUtility.count(carOutExplorer.setBaseNode(3)));
    i = carOutExplorer.setBaseNode(3);
    i.next();
    assertEquals(2, i.getAdjNode());

    i = carOutExplorer.setBaseNode(1);
    assertTrue(i.next());
    assertEquals(12, i.getAdjNode());
    assertTrue(i.next());
    assertEquals(11, i.getAdjNode());
    assertTrue(i.next());
    assertEquals(2, i.getAdjNode());
    assertFalse(i.next());
  }
 @Test
 public void testFootMix() {
   graph = createGraph();
   graph.edge(0, 1).setDistance(10).setFlags(footEncoder.setProperties(10, true, true));
   graph.edge(0, 2).setDistance(10).setFlags(carEncoder.setProperties(10, true, true));
   graph
       .edge(0, 3)
       .setDistance(10)
       .setFlags(
           footEncoder.setProperties(10, true, true) | carEncoder.setProperties(10, true, true));
   EdgeExplorer footOutExplorer =
       graph.createEdgeExplorer(new DefaultEdgeFilter(footEncoder, false, true));
   assertEquals(GHUtility.asSet(3, 1), GHUtility.getNeighbors(footOutExplorer.setBaseNode(0)));
   assertEquals(GHUtility.asSet(3, 2), GHUtility.getNeighbors(carOutExplorer.setBaseNode(0)));
 }
  @Test
  public void testSimpleDelete2() {
    graph = createGraph();
    NodeAccess na = graph.getNodeAccess();
    assertEquals(-1, getIdOf(graph, 12));
    na.setNode(9, 9, 1);
    assertEquals(-1, getIdOf(graph, 12));

    na.setNode(11, 11, 1);
    na.setNode(12, 12, 1);

    // mini subnetwork which gets completely removed:
    graph.edge(5, 10, 510, true);
    graph.markNodeRemoved(5);
    graph.markNodeRemoved(10);

    PointList pl = new PointList();
    pl.add(1, 2, Double.NaN);
    pl.add(1, 3, Double.NaN);
    graph.edge(9, 11, 911, true).setWayGeometry(pl);
    graph.edge(9, 12, 912, true).setWayGeometry(pl);

    assertEquals(13, graph.getNodes());
    assertEquals(Arrays.<String>asList(), GHUtility.getProblems(graph));

    // perform deletion
    graph.optimize();

    assertEquals(11, graph.getNodes());
    assertEquals(Arrays.<String>asList(), GHUtility.getProblems(graph));

    int id11 = getIdOf(graph, 11); // is now 10
    int id12 = getIdOf(graph, 12); // is now 5
    int id9 = getIdOf(graph, 9); // is now 9
    assertEquals(
        GHUtility.asSet(id12, id11), GHUtility.getNeighbors(carAllExplorer.setBaseNode(id9)));
    assertEquals(GHUtility.asSet(id9), GHUtility.getNeighbors(carAllExplorer.setBaseNode(id11)));
    assertEquals(GHUtility.asSet(id9), GHUtility.getNeighbors(carAllExplorer.setBaseNode(id12)));

    EdgeIterator iter = carAllExplorer.setBaseNode(id9);
    assertTrue(iter.next());
    assertEquals(id12, iter.getAdjNode());
    assertEquals(2, iter.fetchWayGeometry(0).getLongitude(0), 1e-7);

    assertTrue(iter.next());
    assertEquals(id11, iter.getAdjNode());
    assertEquals(2, iter.fetchWayGeometry(0).getLongitude(0), 1e-7);
  }
 @Test
 public void testIdenticalNodes2() {
   graph = createGraph();
   graph.edge(0, 0, 100, false);
   graph.edge(0, 0, 100, false);
   assertEquals(2, GHUtility.count(carAllExplorer.setBaseNode(0)));
 }
 @Test
 public void testSetNodes() {
   graph = createGraph();
   NodeAccess na = graph.getNodeAccess();
   for (int i = 0; i < defaultSize * 2; i++) {
     na.setNode(i, 2 * i, 3 * i);
   }
   graph.edge(defaultSize + 1, defaultSize + 2, 10, true);
   graph.edge(defaultSize + 1, defaultSize + 3, 10, true);
   assertEquals(2, GHUtility.count(carAllExplorer.setBaseNode(defaultSize + 1)));
 }
  @Test
  public void testFlags() {
    graph = createGraph();
    graph.edge(0, 1).setDistance(10).setFlags(carEncoder.setProperties(100, true, true));
    graph.edge(2, 3).setDistance(10).setFlags(carEncoder.setProperties(10, true, false));

    EdgeIterator iter = carAllExplorer.setBaseNode(0);
    assertTrue(iter.next());
    assertEquals(carEncoder.setProperties(100, true, true), iter.getFlags());

    iter = carAllExplorer.setBaseNode(2);
    assertTrue(iter.next());
    assertEquals(carEncoder.setProperties(10, true, false), iter.getFlags());

    try {
      graph.edge(0, 1).setDistance(-1);
      assertTrue(false);
    } catch (IllegalArgumentException ex) {
    }
  }
  @Test
  public void testCreateDuplicateEdges() {
    graph = createGraph();
    graph.edge(2, 1, 12, true);
    graph.edge(2, 3, 12, true);
    graph.edge(2, 3, 13, false);
    assertEquals(3, GHUtility.count(carOutExplorer.setBaseNode(2)));

    // no exception
    graph.getEdgeProps(1, 3);

    // raise exception
    try {
      graph.getEdgeProps(4, 3);
      assertTrue(false);
    } catch (Exception ex) {
    }
    try {
      graph.getEdgeProps(-1, 3);
      assertTrue(false);
    } catch (Exception ex) {
    }

    EdgeIterator iter = carOutExplorer.setBaseNode(2);
    assertTrue(iter.next());
    EdgeIteratorState oneIter = graph.getEdgeProps(iter.getEdge(), 3);
    assertEquals(13, oneIter.getDistance(), 1e-6);
    assertEquals(2, oneIter.getBaseNode());
    assertTrue(carEncoder.isBool(oneIter.getFlags(), FlagEncoder.K_FORWARD));
    assertFalse(carEncoder.isBool(oneIter.getFlags(), FlagEncoder.K_BACKWARD));

    oneIter = graph.getEdgeProps(iter.getEdge(), 2);
    assertEquals(13, oneIter.getDistance(), 1e-6);
    assertEquals(3, oneIter.getBaseNode());
    assertFalse(carEncoder.isBool(oneIter.getFlags(), FlagEncoder.K_FORWARD));
    assertTrue(carEncoder.isBool(oneIter.getFlags(), FlagEncoder.K_BACKWARD));

    graph.edge(3, 2, 14, true);
    assertEquals(4, GHUtility.count(carOutExplorer.setBaseNode(2)));
  }
  @Test
  public void testUpdateUnidirectional() {
    graph = createGraph();

    graph.edge(1, 2, 12, false);
    graph.edge(3, 2, 112, false);
    EdgeIterator i = carOutExplorer.setBaseNode(2);
    assertFalse(i.next());
    i = carOutExplorer.setBaseNode(3);
    assertTrue(i.next());
    assertEquals(2, i.getAdjNode());
    assertFalse(i.next());

    graph.edge(2, 3, 112, false);
    i = carOutExplorer.setBaseNode(2);
    assertTrue(i.next());
    assertEquals(3, i.getAdjNode());
    i = carOutExplorer.setBaseNode(3);
    i.next();
    assertEquals(2, i.getAdjNode());
    assertFalse(i.next());
  }
  private void checkExampleGraph(Graph graph) {
    NodeAccess na = graph.getNodeAccess();
    assertEquals(12f, na.getLatitude(0), 1e-6);
    assertEquals(23f, na.getLongitude(0), 1e-6);

    assertEquals(38.33f, na.getLatitude(1), 1e-6);
    assertEquals(135.3f, na.getLongitude(1), 1e-6);

    assertEquals(6, na.getLatitude(2), 1e-6);
    assertEquals(139, na.getLongitude(2), 1e-6);

    assertEquals(78, na.getLatitude(3), 1e-6);
    assertEquals(89, na.getLongitude(3), 1e-6);

    assertEquals(GHUtility.asSet(0), GHUtility.getNeighbors(carOutExplorer.setBaseNode((1))));
    assertEquals(
        GHUtility.asSet(5, 4, 3, 2, 1), GHUtility.getNeighbors(carOutExplorer.setBaseNode(0)));
    try {
      assertEquals(0, count(carOutExplorer.setBaseNode(6)));
      // for now return empty iterator
      // assertFalse(true);
    } catch (Exception ex) {
    }
  }
  protected void checkGraph(Graph g) {
    NodeAccess na = g.getNodeAccess();
    assertTrue(na.is3D());
    assertTrue(g.getBounds().isValid());

    assertEquals(new BBox(10, 20, 10, 12, 0, 1), g.getBounds());
    assertEquals(10, na.getLatitude(0), 1e-2);
    assertEquals(10, na.getLongitude(0), 1e-2);
    EdgeExplorer explorer = g.createEdgeExplorer(carOutFilter);
    assertEquals(2, GHUtility.count(explorer.setBaseNode(0)));
    assertEquals(GHUtility.asSet(2, 1), GHUtility.getNeighbors(explorer.setBaseNode(0)));

    EdgeIterator iter = explorer.setBaseNode(0);
    assertTrue(iter.next());
    assertEquals(Helper.createPointList3D(3.5, 4.5, 0, 5, 6, 0), iter.fetchWayGeometry(0));

    assertTrue(iter.next());
    assertEquals(Helper.createPointList3D(1.5, 1, 0, 2, 3, 0), iter.fetchWayGeometry(0));
    assertEquals(Helper.createPointList3D(10, 10, 0, 1.5, 1, 0, 2, 3, 0), iter.fetchWayGeometry(1));
    assertEquals(Helper.createPointList3D(1.5, 1, 0, 2, 3, 0, 11, 20, 1), iter.fetchWayGeometry(2));

    assertEquals(11, na.getLatitude(1), 1e-2);
    assertEquals(20, na.getLongitude(1), 1e-2);
    assertEquals(2, GHUtility.count(explorer.setBaseNode(1)));
    assertEquals(GHUtility.asSet(2, 0), GHUtility.getNeighbors(explorer.setBaseNode(1)));

    assertEquals(12, na.getLatitude(2), 1e-2);
    assertEquals(12, na.getLongitude(2), 1e-2);
    assertEquals(1, GHUtility.count(explorer.setBaseNode(2)));

    assertEquals(GHUtility.asSet(0), GHUtility.getNeighbors(explorer.setBaseNode(2)));

    EdgeIteratorState eib = GHUtility.getEdge(g, 1, 2);
    assertEquals(Helper.createPointList3D(), eib.fetchWayGeometry(0));
    assertEquals(Helper.createPointList3D(11, 20, 1), eib.fetchWayGeometry(1));
    assertEquals(Helper.createPointList3D(12, 12, 0.4), eib.fetchWayGeometry(2));
    assertEquals(GHUtility.asSet(0), GHUtility.getNeighbors(explorer.setBaseNode(2)));
  }
  @Test
  public void testClone() {
    graph = createGraph();
    graph.edge(1, 2, 10, true);
    NodeAccess na = graph.getNodeAccess();
    na.setNode(0, 12, 23);
    na.setNode(1, 8, 13);
    na.setNode(2, 2, 10);
    na.setNode(3, 5, 9);
    graph.edge(1, 3, 10, true);

    Graph clone = graph.copyTo(createGraph(locationParent + "/clone", false));
    assertEquals(graph.getNodes(), clone.getNodes());
    assertEquals(
        count(carOutExplorer.setBaseNode(1)),
        count(clone.createEdgeExplorer(carOutFilter).setBaseNode(1)));
    clone.edge(1, 4, 10, true);
    assertEquals(3, count(clone.createEdgeExplorer(carOutFilter).setBaseNode(1)));
    assertEquals(graph.getBounds(), clone.getBounds());
    Helper.close((Closeable) clone);
  }
  @Test
  public void testPillarNodes() {
    graph = createGraph();
    NodeAccess na = graph.getNodeAccess();
    na.setNode(0, 0.01, 0.01);
    na.setNode(4, 0.4, 0.4);
    na.setNode(14, 0.14, 0.14);
    na.setNode(10, 0.99, 0.99);

    PointList pointList = Helper.createPointList(1, 1, 1, 2, 1, 3);
    graph
        .edge(0, 4)
        .setDistance(100)
        .setFlags(carEncoder.setProperties(10, true, false))
        .setWayGeometry(pointList);
    pointList = Helper.createPointList(1, 5, 1, 6, 1, 7, 1, 8, 1, 9);
    graph
        .edge(4, 10)
        .setDistance(100)
        .setFlags(carEncoder.setProperties(10, true, false))
        .setWayGeometry(pointList);
    pointList = Helper.createPointList(1, 13, 1, 12, 1, 11);
    graph
        .edge(14, 0)
        .setDistance(100)
        .setFlags(carEncoder.setProperties(10, true, false))
        .setWayGeometry(pointList);

    EdgeIterator iter = carAllExplorer.setBaseNode(0);
    assertTrue(iter.next());
    assertEquals(14, iter.getAdjNode());
    assertPList(Helper.createPointList(1, 11, 1, 12, 1, 13.0), iter.fetchWayGeometry(0));
    assertPList(
        Helper.createPointList(0.01, 0.01, 1, 11, 1, 12, 1, 13.0), iter.fetchWayGeometry(1));
    assertPList(
        Helper.createPointList(1, 11, 1, 12, 1, 13.0, 0.14, 0.14), iter.fetchWayGeometry(2));
    assertPList(
        Helper.createPointList(0.01, 0.01, 1, 11, 1, 12, 1, 13.0, 0.14, 0.14),
        iter.fetchWayGeometry(3));

    assertTrue(iter.next());
    assertEquals(4, iter.getAdjNode());
    assertPList(Helper.createPointList(1, 1, 1, 2, 1, 3), iter.fetchWayGeometry(0));
    assertPList(Helper.createPointList(0.01, 0.01, 1, 1, 1, 2, 1, 3), iter.fetchWayGeometry(1));
    assertPList(Helper.createPointList(1, 1, 1, 2, 1, 3, 0.4, 0.4), iter.fetchWayGeometry(2));
    assertPList(
        Helper.createPointList(0.01, 0.01, 1, 1, 1, 2, 1, 3, 0.4, 0.4), iter.fetchWayGeometry(3));

    assertFalse(iter.next());

    iter = carOutExplorer.setBaseNode(0);
    assertTrue(iter.next());
    assertEquals(4, iter.getAdjNode());
    assertPList(Helper.createPointList(1, 1, 1, 2, 1, 3), iter.fetchWayGeometry(0));
    assertFalse(iter.next());

    iter = carInExplorer.setBaseNode(10);
    assertTrue(iter.next());
    assertEquals(4, iter.getAdjNode());
    assertPList(Helper.createPointList(1, 9, 1, 8, 1, 7, 1, 6, 1, 5), iter.fetchWayGeometry(0));
    assertPList(
        Helper.createPointList(0.99, 0.99, 1, 9, 1, 8, 1, 7, 1, 6, 1, 5), iter.fetchWayGeometry(1));
    assertPList(
        Helper.createPointList(1, 9, 1, 8, 1, 7, 1, 6, 1, 5, 0.4, 0.4), iter.fetchWayGeometry(2));
    assertPList(
        Helper.createPointList(0.99, 0.99, 1, 9, 1, 8, 1, 7, 1, 6, 1, 5, 0.4, 0.4),
        iter.fetchWayGeometry(3));
    assertFalse(iter.next());
  }
  @Test
  public void testDirectional() {
    graph = createGraph();
    graph.edge(1, 2, 12, true);
    graph.edge(2, 3, 12, false);
    graph.edge(3, 4, 12, false);
    graph.edge(3, 5, 12, true);
    graph.edge(6, 3, 12, false);

    assertEquals(1, count(carAllExplorer.setBaseNode(1)));
    assertEquals(1, count(carInExplorer.setBaseNode(1)));
    assertEquals(1, count(carOutExplorer.setBaseNode(1)));

    assertEquals(2, count(carAllExplorer.setBaseNode(2)));
    assertEquals(1, count(carInExplorer.setBaseNode(2)));
    assertEquals(2, count(carOutExplorer.setBaseNode(2)));

    assertEquals(4, count(carAllExplorer.setBaseNode(3)));
    assertEquals(3, count(carInExplorer.setBaseNode(3)));
    assertEquals(2, count(carOutExplorer.setBaseNode(3)));

    assertEquals(1, count(carAllExplorer.setBaseNode(4)));
    assertEquals(1, count(carInExplorer.setBaseNode(4)));
    assertEquals(0, count(carOutExplorer.setBaseNode(4)));

    assertEquals(1, count(carAllExplorer.setBaseNode(5)));
    assertEquals(1, count(carInExplorer.setBaseNode(5)));
    assertEquals(1, count(carOutExplorer.setBaseNode(5)));
  }