@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 testEdgeReturn() {
   graph = createGraph();
   EdgeIteratorState iter =
       graph.edge(4, 10).setDistance(100).setFlags(carEncoder.setProperties(10, true, false));
   assertEquals(4, iter.getBaseNode());
   assertEquals(10, iter.getAdjNode());
   iter = graph.edge(14, 10).setDistance(100).setFlags(carEncoder.setProperties(10, true, false));
   assertEquals(14, iter.getBaseNode());
   assertEquals(10, iter.getAdjNode());
 }
  @Test
  public void testNameIndex() {
    graph = createGraph();
    EdgeIteratorState iter1 = graph.edge(0, 1, 10, true);
    iter1.setName("named street1");

    EdgeIteratorState iter2 = graph.edge(0, 1, 10, true);
    iter2.setName("named street2");

    assertEquals(
        "named street1", graph.getEdgeProps(iter1.getEdge(), iter1.getAdjNode()).getName());
    assertEquals(
        "named street2", graph.getEdgeProps(iter2.getEdge(), iter2.getAdjNode()).getName());
  }
  @Test
  public void testDetachEdge() {
    graph = createGraph();
    graph.edge(0, 1, 2, true);
    long flags = carEncoder.setProperties(10, true, false);
    graph.edge(0, 2, 2, true).setWayGeometry(Helper.createPointList(1, 2, 3, 4)).setFlags(flags);
    graph.edge(1, 2, 2, true);

    EdgeIterator iter = graph.createEdgeExplorer().setBaseNode(0);
    try {
      // currently not possible to detach without next, without introducing a new property inside
      // EdgeIterable
      iter.detach(false);
      assertTrue(false);
    } catch (Exception ex) {
    }

    iter.next();
    EdgeIteratorState edgeState2 = iter.detach(false);
    assertEquals(2, iter.getAdjNode());
    assertEquals(1, edgeState2.fetchWayGeometry(0).getLatitude(0), 1e-1);
    assertEquals(2, edgeState2.getAdjNode());
    assertTrue(carEncoder.isBool(edgeState2.getFlags(), FlagEncoder.K_FORWARD));

    EdgeIteratorState edgeState3 = iter.detach(true);
    assertEquals(0, edgeState3.getAdjNode());
    assertEquals(2, edgeState3.getBaseNode());
    assertEquals(3, edgeState3.fetchWayGeometry(0).getLatitude(0), 1e-1);
    assertFalse(carEncoder.isBool(edgeState3.getFlags(), FlagEncoder.K_FORWARD));
    assertEquals(GHUtility.getEdge(graph, 0, 2).getFlags(), edgeState2.getFlags());
    assertEquals(GHUtility.getEdge(graph, 2, 0).getFlags(), edgeState3.getFlags());

    iter.next();
    assertEquals(1, iter.getAdjNode());
    assertEquals(2, edgeState2.getAdjNode());
    assertEquals(2, edgeState3.getBaseNode());

    assertEquals(0, iter.fetchWayGeometry(0).size());
    assertEquals(1, edgeState2.fetchWayGeometry(0).getLatitude(0), 1e-1);
    assertEquals(3, edgeState3.fetchWayGeometry(0).getLatitude(0), 1e-1);

    // #162 a directed self referencing edge should be able to reverse its state too
    graph.edge(3, 3, 2, true).setFlags(flags);
    EdgeIterator iter2 = graph.createEdgeExplorer().setBaseNode(3);
    iter2.next();
    assertEquals(edgeState2.getFlags(), iter2.detach(false).getFlags());
    assertEquals(edgeState3.getFlags(), iter2.detach(true).getFlags());
  }
  @Test
  public void testEdgeProperties() {
    graph = createGraph();
    EdgeIteratorState iter1 = graph.edge(0, 1, 10, true);
    EdgeIteratorState iter2 = graph.edge(0, 2, 20, true);

    int edgeId = iter1.getEdge();
    EdgeIteratorState iter = graph.getEdgeProps(edgeId, 0);
    assertEquals(10, iter.getDistance(), 1e-5);

    edgeId = iter2.getEdge();
    iter = graph.getEdgeProps(edgeId, 0);
    assertEquals(2, iter.getBaseNode());
    assertEquals(0, iter.getAdjNode());
    assertEquals(20, iter.getDistance(), 1e-5);

    iter = graph.getEdgeProps(edgeId, 2);
    assertEquals(0, iter.getBaseNode());
    assertEquals(2, iter.getAdjNode());
    assertEquals(20, iter.getDistance(), 1e-5);

    iter = graph.getEdgeProps(edgeId, Integer.MIN_VALUE);
    assertFalse(iter == null);
    assertEquals(0, iter.getBaseNode());
    assertEquals(2, iter.getAdjNode());
    iter = graph.getEdgeProps(edgeId, 1);
    assertTrue(iter == null);

    // delete
    graph.markNodeRemoved(1);
    graph.optimize();

    // throw exception if accessing deleted edge
    try {
      graph.getEdgeProps(iter1.getEdge(), -1);
      assertTrue(false);
    } catch (Exception ex) {
    }
  }
  @Test
  public void testSave_and_fileFormat() throws IOException {
    graph = newGHStorage(new RAMDirectory(defaultGraphLoc, true), true).create(defaultSize);
    NodeAccess na = graph.getNodeAccess();
    assertTrue(na.is3D());
    na.setNode(0, 10, 10, 0);
    na.setNode(1, 11, 20, 1);
    na.setNode(2, 12, 12, 0.4);

    EdgeIteratorState iter2 = graph.edge(0, 1, 100, true);
    iter2.setWayGeometry(Helper.createPointList3D(1.5, 1, 0, 2, 3, 0));
    EdgeIteratorState iter1 = graph.edge(0, 2, 200, true);
    iter1.setWayGeometry(Helper.createPointList3D(3.5, 4.5, 0, 5, 6, 0));
    graph.edge(9, 10, 200, true);
    graph.edge(9, 11, 200, true);
    graph.edge(1, 2, 120, false);

    iter1.setName("named street1");
    iter2.setName("named street2");

    checkGraph(graph);
    graph.flush();
    graph.close();

    graph = newGHStorage(new MMapDirectory(defaultGraphLoc), true);
    assertTrue(graph.loadExisting());

    assertEquals(12, graph.getNodes());
    checkGraph(graph);

    assertEquals(
        "named street1", graph.getEdgeIteratorState(iter1.getEdge(), iter1.getAdjNode()).getName());
    assertEquals(
        "named street2", graph.getEdgeIteratorState(iter2.getEdge(), iter2.getAdjNode()).getName());
    graph.edge(3, 4, 123, true).setWayGeometry(Helper.createPointList3D(4.4, 5.5, 0, 6.6, 7.7, 0));
    checkGraph(graph);
  }