diff --git a/java/server/src/test/java/org/softwareheritage/graph/LeavesTest.java b/java/server/src/test/java/org/softwareheritage/graph/LeavesTest.java
index 104a7a2..45e32e3 100644
--- a/java/server/src/test/java/org/softwareheritage/graph/LeavesTest.java
+++ b/java/server/src/test/java/org/softwareheritage/graph/LeavesTest.java
@@ -1,110 +1,111 @@
 package org.softwareheritage.graph;
 
 import java.util.ArrayList;
 
 import org.junit.Test;
 
 import org.softwareheritage.graph.Endpoint;
 import org.softwareheritage.graph.Graph;
 import org.softwareheritage.graph.GraphTest;
 import org.softwareheritage.graph.SwhPID;
 
 // Avoid warnings concerning Endpoint.Output.result manual cast
 @SuppressWarnings("unchecked")
 public class LeavesTest extends GraphTest {
   @Test
   public void forwardFromSnp() {
     Graph graph = getGraph();
     SwhPID src = new SwhPID("swh:1:snp:0000000000000000000000000000000000000020");
     Endpoint endpoint = new Endpoint(graph, "forward", "*");
 
     ArrayList<SwhPID> expectedLeaves = new ArrayList<>();
     expectedLeaves.add(new SwhPID("swh:1:cnt:0000000000000000000000000000000000000001"));
     expectedLeaves.add(new SwhPID("swh:1:cnt:0000000000000000000000000000000000000004"));
     expectedLeaves.add(new SwhPID("swh:1:cnt:0000000000000000000000000000000000000005"));
     expectedLeaves.add(new SwhPID("swh:1:cnt:0000000000000000000000000000000000000007"));
 
     ArrayList<SwhPID> actualLeaves = (ArrayList) endpoint.leaves(new Endpoint.Input(src)).result;
     GraphTest.assertEqualsAnyOrder(expectedLeaves, actualLeaves);
   }
 
   @Test
   public void forwardFromRel() {
     Graph graph = getGraph();
     SwhPID src = new SwhPID("swh:1:rel:0000000000000000000000000000000000000019");
     Endpoint endpoint = new Endpoint(graph, "forward", "*");
 
     ArrayList<SwhPID> expectedLeaves = new ArrayList<>();
     expectedLeaves.add(new SwhPID("swh:1:cnt:0000000000000000000000000000000000000015"));
     expectedLeaves.add(new SwhPID("swh:1:cnt:0000000000000000000000000000000000000014"));
     expectedLeaves.add(new SwhPID("swh:1:cnt:0000000000000000000000000000000000000001"));
     expectedLeaves.add(new SwhPID("swh:1:cnt:0000000000000000000000000000000000000004"));
     expectedLeaves.add(new SwhPID("swh:1:cnt:0000000000000000000000000000000000000005"));
     expectedLeaves.add(new SwhPID("swh:1:cnt:0000000000000000000000000000000000000007"));
     expectedLeaves.add(new SwhPID("swh:1:cnt:0000000000000000000000000000000000000011"));
 
     ArrayList<SwhPID> actualLeaves = (ArrayList) endpoint.leaves(new Endpoint.Input(src)).result;
     GraphTest.assertEqualsAnyOrder(expectedLeaves, actualLeaves);
   }
 
   @Test
   public void backwardFromLeaf() {
     Graph graph = getGraph();
-    Endpoint endpoint = new Endpoint(graph, "backward", "*");
 
+    Endpoint endpoint1 = new Endpoint(graph, "backward", "*");
     SwhPID src1 = new SwhPID("swh:1:cnt:0000000000000000000000000000000000000015");
     ArrayList<SwhPID> expectedLeaves1 = new ArrayList<>();
     expectedLeaves1.add(new SwhPID("swh:1:rel:0000000000000000000000000000000000000019"));
-    ArrayList<SwhPID> actualLeaves1 = (ArrayList) endpoint.leaves(new Endpoint.Input(src1)).result;
+    ArrayList<SwhPID> actualLeaves1 = (ArrayList) endpoint1.leaves(new Endpoint.Input(src1)).result;
     GraphTest.assertEqualsAnyOrder(expectedLeaves1, actualLeaves1);
 
+    Endpoint endpoint2 = new Endpoint(graph, "backward", "*");
     SwhPID src2 = new SwhPID("swh:1:cnt:0000000000000000000000000000000000000004");
     ArrayList<SwhPID> expectedLeaves2 = new ArrayList<>();
     expectedLeaves2.add(new SwhPID("swh:1:ori:0000000000000000000000000000000000000021"));
     expectedLeaves2.add(new SwhPID("swh:1:rel:0000000000000000000000000000000000000019"));
-    ArrayList<SwhPID> actualLeaves2 = (ArrayList) endpoint.leaves(new Endpoint.Input(src2)).result;
+    ArrayList<SwhPID> actualLeaves2 = (ArrayList) endpoint2.leaves(new Endpoint.Input(src2)).result;
     GraphTest.assertEqualsAnyOrder(expectedLeaves2, actualLeaves2);
   }
 
   @Test
   public void forwardRevToRevOnly() {
     Graph graph = getGraph();
     SwhPID src = new SwhPID("swh:1:rev:0000000000000000000000000000000000000018");
     Endpoint endpoint = new Endpoint(graph, "forward", "rev:rev");
 
     ArrayList<SwhPID> expectedLeaves = new ArrayList<>();
     expectedLeaves.add(new SwhPID("swh:1:rev:0000000000000000000000000000000000000003"));
 
     ArrayList<SwhPID> actualLeaves = (ArrayList) endpoint.leaves(new Endpoint.Input(src)).result;
     GraphTest.assertEqualsAnyOrder(expectedLeaves, actualLeaves);
   }
 
   @Test
   public void forwardDirToAll() {
     Graph graph = getGraph();
     SwhPID src = new SwhPID("swh:1:dir:0000000000000000000000000000000000000008");
     Endpoint endpoint = new Endpoint(graph, "forward", "dir:*");
 
     ArrayList<SwhPID> expectedLeaves = new ArrayList<>();
     expectedLeaves.add(new SwhPID("swh:1:cnt:0000000000000000000000000000000000000004"));
     expectedLeaves.add(new SwhPID("swh:1:cnt:0000000000000000000000000000000000000005"));
     expectedLeaves.add(new SwhPID("swh:1:cnt:0000000000000000000000000000000000000001"));
     expectedLeaves.add(new SwhPID("swh:1:cnt:0000000000000000000000000000000000000007"));
 
     ArrayList<SwhPID> actualLeaves = (ArrayList) endpoint.leaves(new Endpoint.Input(src)).result;
     GraphTest.assertEqualsAnyOrder(expectedLeaves, actualLeaves);
   }
 
   @Test
   public void backwardCntToDirDirToDir() {
     Graph graph = getGraph();
     SwhPID src = new SwhPID("swh:1:cnt:0000000000000000000000000000000000000005");
     Endpoint endpoint = new Endpoint(graph, "backward", "cnt:dir,dir:dir");
 
     ArrayList<SwhPID> expectedLeaves = new ArrayList<>();
     expectedLeaves.add(new SwhPID("swh:1:dir:0000000000000000000000000000000000000012"));
 
     ArrayList<SwhPID> actualLeaves = (ArrayList) endpoint.leaves(new Endpoint.Input(src)).result;
     GraphTest.assertEqualsAnyOrder(expectedLeaves, actualLeaves);
   }
 }
diff --git a/java/server/src/test/java/org/softwareheritage/graph/VisitTest.java b/java/server/src/test/java/org/softwareheritage/graph/VisitTest.java
index 0783913..fff3a28 100644
--- a/java/server/src/test/java/org/softwareheritage/graph/VisitTest.java
+++ b/java/server/src/test/java/org/softwareheritage/graph/VisitTest.java
@@ -1,535 +1,547 @@
 package org.softwareheritage.graph;
 
 import java.util.ArrayList;
 import java.util.Set;
 import java.util.HashSet;
 
 import org.junit.Test;
 
 import org.softwareheritage.graph.Endpoint;
 import org.softwareheritage.graph.Graph;
 import org.softwareheritage.graph.GraphTest;
 import org.softwareheritage.graph.SwhPID;
 import org.softwareheritage.graph.SwhPath;
 
 // Avoid warnings concerning Endpoint.Output.result manual cast
 @SuppressWarnings("unchecked")
 public class VisitTest extends GraphTest {
   private void assertSameNodesFromPaths(ArrayList<SwhPath> paths, ArrayList<SwhPID> nodes) {
     Set<SwhPID> expectedNodes = new HashSet<SwhPID>();
     for (SwhPath path : paths) {
       for (SwhPID node : path.getPath()) {
         expectedNodes.add(node);
       }
     }
     GraphTest.assertEqualsAnyOrder(expectedNodes, nodes);
   }
 
   @Test
   public void forwardFromRoot() {
     Graph graph = getGraph();
     SwhPID swhPID = new SwhPID("swh:1:ori:0000000000000000000000000000000000000021");
-    Endpoint endpoint = new Endpoint(graph, "forward", "*");
-    ArrayList<SwhPath> paths = (ArrayList) endpoint.visitPaths(new Endpoint.Input(swhPID)).result;
-    ArrayList<SwhPID> nodes = (ArrayList) endpoint.visitNodes(new Endpoint.Input(swhPID)).result;
+    Endpoint endpoint1 = new Endpoint(graph, "forward", "*");
+    ArrayList<SwhPath> paths = (ArrayList) endpoint1.visitPaths(new Endpoint.Input(swhPID)).result;
+    Endpoint endpoint2 = new Endpoint(graph, "forward", "*");
+    ArrayList<SwhPID> nodes = (ArrayList) endpoint2.visitNodes(new Endpoint.Input(swhPID)).result;
 
     ArrayList<SwhPath> expectedPaths = new ArrayList<SwhPath>();
     expectedPaths.add(
         new SwhPath(
           "swh:1:ori:0000000000000000000000000000000000000021",
           "swh:1:snp:0000000000000000000000000000000000000020",
           "swh:1:rev:0000000000000000000000000000000000000009",
           "swh:1:dir:0000000000000000000000000000000000000008",
           "swh:1:cnt:0000000000000000000000000000000000000007"
         ));
     expectedPaths.add(
         new SwhPath(
           "swh:1:ori:0000000000000000000000000000000000000021",
           "swh:1:snp:0000000000000000000000000000000000000020",
           "swh:1:rev:0000000000000000000000000000000000000009",
           "swh:1:dir:0000000000000000000000000000000000000008",
           "swh:1:cnt:0000000000000000000000000000000000000001"
         ));
     expectedPaths.add(
         new SwhPath(
           "swh:1:ori:0000000000000000000000000000000000000021",
           "swh:1:snp:0000000000000000000000000000000000000020",
           "swh:1:rev:0000000000000000000000000000000000000009",
           "swh:1:dir:0000000000000000000000000000000000000008",
           "swh:1:dir:0000000000000000000000000000000000000006",
           "swh:1:cnt:0000000000000000000000000000000000000004"
         ));
     expectedPaths.add(
         new SwhPath(
           "swh:1:ori:0000000000000000000000000000000000000021",
           "swh:1:snp:0000000000000000000000000000000000000020",
           "swh:1:rev:0000000000000000000000000000000000000009",
           "swh:1:dir:0000000000000000000000000000000000000008",
           "swh:1:dir:0000000000000000000000000000000000000006",
           "swh:1:cnt:0000000000000000000000000000000000000005"
         ));
     expectedPaths.add(
         new SwhPath(
           "swh:1:ori:0000000000000000000000000000000000000021",
           "swh:1:snp:0000000000000000000000000000000000000020",
           "swh:1:rev:0000000000000000000000000000000000000009",
           "swh:1:rev:0000000000000000000000000000000000000003",
           "swh:1:dir:0000000000000000000000000000000000000002",
           "swh:1:cnt:0000000000000000000000000000000000000001"
         ));
     expectedPaths.add(
         new SwhPath(
           "swh:1:ori:0000000000000000000000000000000000000021",
           "swh:1:snp:0000000000000000000000000000000000000020",
           "swh:1:rel:0000000000000000000000000000000000000010",
           "swh:1:rev:0000000000000000000000000000000000000009",
           "swh:1:dir:0000000000000000000000000000000000000008",
           "swh:1:cnt:0000000000000000000000000000000000000007"
         ));
     expectedPaths.add(
         new SwhPath(
           "swh:1:ori:0000000000000000000000000000000000000021",
           "swh:1:snp:0000000000000000000000000000000000000020",
           "swh:1:rel:0000000000000000000000000000000000000010",
           "swh:1:rev:0000000000000000000000000000000000000009",
           "swh:1:dir:0000000000000000000000000000000000000008",
           "swh:1:cnt:0000000000000000000000000000000000000001"
         ));
     expectedPaths.add(
         new SwhPath(
           "swh:1:ori:0000000000000000000000000000000000000021",
           "swh:1:snp:0000000000000000000000000000000000000020",
           "swh:1:rel:0000000000000000000000000000000000000010",
           "swh:1:rev:0000000000000000000000000000000000000009",
           "swh:1:dir:0000000000000000000000000000000000000008",
           "swh:1:dir:0000000000000000000000000000000000000006",
           "swh:1:cnt:0000000000000000000000000000000000000004"
         ));
     expectedPaths.add(
         new SwhPath(
           "swh:1:ori:0000000000000000000000000000000000000021",
           "swh:1:snp:0000000000000000000000000000000000000020",
           "swh:1:rel:0000000000000000000000000000000000000010",
           "swh:1:rev:0000000000000000000000000000000000000009",
           "swh:1:dir:0000000000000000000000000000000000000008",
           "swh:1:dir:0000000000000000000000000000000000000006",
           "swh:1:cnt:0000000000000000000000000000000000000005"
         ));
     expectedPaths.add(
         new SwhPath(
           "swh:1:ori:0000000000000000000000000000000000000021",
           "swh:1:snp:0000000000000000000000000000000000000020",
           "swh:1:rel:0000000000000000000000000000000000000010",
           "swh:1:rev:0000000000000000000000000000000000000009",
           "swh:1:rev:0000000000000000000000000000000000000003",
           "swh:1:dir:0000000000000000000000000000000000000002",
           "swh:1:cnt:0000000000000000000000000000000000000001"
         ));
 
     GraphTest.assertEqualsAnyOrder(expectedPaths, paths);
     assertSameNodesFromPaths(expectedPaths, nodes);
   }
 
   @Test
   public void forwardFromMiddle() {
     Graph graph = getGraph();
     SwhPID swhPID = new SwhPID("swh:1:dir:0000000000000000000000000000000000000012");
-    Endpoint endpoint = new Endpoint(graph, "forward", "*");
-    ArrayList<SwhPath> paths = (ArrayList) endpoint.visitPaths(new Endpoint.Input(swhPID)).result;
-    ArrayList<SwhPID> nodes = (ArrayList) endpoint.visitNodes(new Endpoint.Input(swhPID)).result;
+    Endpoint endpoint1 = new Endpoint(graph, "forward", "*");
+    ArrayList<SwhPath> paths = (ArrayList) endpoint1.visitPaths(new Endpoint.Input(swhPID)).result;
+    Endpoint endpoint2 = new Endpoint(graph, "forward", "*");
+    ArrayList<SwhPID> nodes = (ArrayList) endpoint2.visitNodes(new Endpoint.Input(swhPID)).result;
 
     ArrayList<SwhPath> expectedPaths = new ArrayList<SwhPath>();
     expectedPaths.add(
         new SwhPath(
           "swh:1:dir:0000000000000000000000000000000000000012",
           "swh:1:dir:0000000000000000000000000000000000000008",
           "swh:1:cnt:0000000000000000000000000000000000000007"
         ));
     expectedPaths.add(
         new SwhPath(
           "swh:1:dir:0000000000000000000000000000000000000012",
           "swh:1:dir:0000000000000000000000000000000000000008",
           "swh:1:cnt:0000000000000000000000000000000000000001"
         ));
     expectedPaths.add(
         new SwhPath(
           "swh:1:dir:0000000000000000000000000000000000000012",
           "swh:1:dir:0000000000000000000000000000000000000008",
           "swh:1:dir:0000000000000000000000000000000000000006",
           "swh:1:cnt:0000000000000000000000000000000000000004"
         ));
     expectedPaths.add(
         new SwhPath(
           "swh:1:dir:0000000000000000000000000000000000000012",
           "swh:1:dir:0000000000000000000000000000000000000008",
           "swh:1:dir:0000000000000000000000000000000000000006",
           "swh:1:cnt:0000000000000000000000000000000000000005"
         ));
     expectedPaths.add(
         new SwhPath(
           "swh:1:dir:0000000000000000000000000000000000000012",
           "swh:1:cnt:0000000000000000000000000000000000000011"
         ));
 
     GraphTest.assertEqualsAnyOrder(expectedPaths, paths);
     assertSameNodesFromPaths(expectedPaths, nodes);
   }
 
   @Test
   public void forwardFromLeaf() {
     Graph graph = getGraph();
     SwhPID swhPID = new SwhPID("swh:1:cnt:0000000000000000000000000000000000000004");
-    Endpoint endpoint = new Endpoint(graph, "forward", "*");
-    ArrayList<SwhPath> paths = (ArrayList) endpoint.visitPaths(new Endpoint.Input(swhPID)).result;
-    ArrayList<SwhPID> nodes = (ArrayList) endpoint.visitNodes(new Endpoint.Input(swhPID)).result;
+    Endpoint endpoint1 = new Endpoint(graph, "forward", "*");
+    ArrayList<SwhPath> paths = (ArrayList) endpoint1.visitPaths(new Endpoint.Input(swhPID)).result;
+    Endpoint endpoint2 = new Endpoint(graph, "forward", "*");
+    ArrayList<SwhPID> nodes = (ArrayList) endpoint2.visitNodes(new Endpoint.Input(swhPID)).result;
 
     ArrayList<SwhPath> expectedPaths = new ArrayList<SwhPath>();
     expectedPaths.add(
         new SwhPath(
           "swh:1:cnt:0000000000000000000000000000000000000004"
         ));
 
     GraphTest.assertEqualsAnyOrder(expectedPaths, paths);
     assertSameNodesFromPaths(expectedPaths, nodes);
   }
 
   @Test
   public void backwardFromRoot() {
     Graph graph = getGraph();
     SwhPID swhPID = new SwhPID("swh:1:ori:0000000000000000000000000000000000000021");
-    Endpoint endpoint = new Endpoint(graph, "backward", "*");
-    ArrayList<SwhPath> paths = (ArrayList) endpoint.visitPaths(new Endpoint.Input(swhPID)).result;
-    ArrayList<SwhPID> nodes = (ArrayList) endpoint.visitNodes(new Endpoint.Input(swhPID)).result;
+    Endpoint endpoint1 = new Endpoint(graph, "backward", "*");
+    ArrayList<SwhPath> paths = (ArrayList) endpoint1.visitPaths(new Endpoint.Input(swhPID)).result;
+    Endpoint endpoint2 = new Endpoint(graph, "backward", "*");
+    ArrayList<SwhPID> nodes = (ArrayList) endpoint2.visitNodes(new Endpoint.Input(swhPID)).result;
 
     ArrayList<SwhPath> expectedPaths = new ArrayList<SwhPath>();
     expectedPaths.add(
         new SwhPath(
           "swh:1:ori:0000000000000000000000000000000000000021"
         ));
 
     GraphTest.assertEqualsAnyOrder(expectedPaths, paths);
     assertSameNodesFromPaths(expectedPaths, nodes);
   }
 
   @Test
   public void backwardFromMiddle() {
     Graph graph = getGraph();
     SwhPID swhPID = new SwhPID("swh:1:dir:0000000000000000000000000000000000000012");
-    Endpoint endpoint = new Endpoint(graph, "backward", "*");
-    ArrayList<SwhPath> paths = (ArrayList) endpoint.visitPaths(new Endpoint.Input(swhPID)).result;
-    ArrayList<SwhPID> nodes = (ArrayList) endpoint.visitNodes(new Endpoint.Input(swhPID)).result;
+    Endpoint endpoint1 = new Endpoint(graph, "backward", "*");
+    ArrayList<SwhPath> paths = (ArrayList) endpoint1.visitPaths(new Endpoint.Input(swhPID)).result;
+    Endpoint endpoint2 = new Endpoint(graph, "backward", "*");
+    ArrayList<SwhPID> nodes = (ArrayList) endpoint2.visitNodes(new Endpoint.Input(swhPID)).result;
 
     ArrayList<SwhPath> expectedPaths = new ArrayList<SwhPath>();
     expectedPaths.add(
         new SwhPath(
           "swh:1:dir:0000000000000000000000000000000000000012",
           "swh:1:rev:0000000000000000000000000000000000000013",
           "swh:1:rev:0000000000000000000000000000000000000018",
           "swh:1:rel:0000000000000000000000000000000000000019"
         ));
 
     GraphTest.assertEqualsAnyOrder(expectedPaths, paths);
     assertSameNodesFromPaths(expectedPaths, nodes);
   }
 
   @Test
   public void backwardFromLeaf() {
     Graph graph = getGraph();
     SwhPID swhPID = new SwhPID("swh:1:cnt:0000000000000000000000000000000000000004");
-    Endpoint endpoint = new Endpoint(graph, "backward", "*");
-    ArrayList<SwhPath> paths = (ArrayList) endpoint.visitPaths(new Endpoint.Input(swhPID)).result;
-    ArrayList<SwhPID> nodes = (ArrayList) endpoint.visitNodes(new Endpoint.Input(swhPID)).result;
+    Endpoint endpoint1 = new Endpoint(graph, "backward", "*");
+    ArrayList<SwhPath> paths = (ArrayList) endpoint1.visitPaths(new Endpoint.Input(swhPID)).result;
+    Endpoint endpoint2 = new Endpoint(graph, "backward", "*");
+    ArrayList<SwhPID> nodes = (ArrayList) endpoint2.visitNodes(new Endpoint.Input(swhPID)).result;
 
     ArrayList<SwhPath> expectedPaths = new ArrayList<SwhPath>();
     expectedPaths.add(
         new SwhPath(
           "swh:1:cnt:0000000000000000000000000000000000000004",
           "swh:1:dir:0000000000000000000000000000000000000006",
           "swh:1:dir:0000000000000000000000000000000000000008",
           "swh:1:dir:0000000000000000000000000000000000000012",
           "swh:1:rev:0000000000000000000000000000000000000013",
           "swh:1:rev:0000000000000000000000000000000000000018",
           "swh:1:rel:0000000000000000000000000000000000000019"
         ));
     expectedPaths.add(
         new SwhPath(
           "swh:1:cnt:0000000000000000000000000000000000000004",
           "swh:1:dir:0000000000000000000000000000000000000006",
           "swh:1:dir:0000000000000000000000000000000000000008",
           "swh:1:rev:0000000000000000000000000000000000000009",
           "swh:1:rev:0000000000000000000000000000000000000013",
           "swh:1:rev:0000000000000000000000000000000000000018",
           "swh:1:rel:0000000000000000000000000000000000000019"
         ));
     expectedPaths.add(
         new SwhPath(
           "swh:1:cnt:0000000000000000000000000000000000000004",
           "swh:1:dir:0000000000000000000000000000000000000006",
           "swh:1:dir:0000000000000000000000000000000000000008",
           "swh:1:rev:0000000000000000000000000000000000000009",
           "swh:1:snp:0000000000000000000000000000000000000020",
           "swh:1:ori:0000000000000000000000000000000000000021"
         ));
     expectedPaths.add(
         new SwhPath(
           "swh:1:cnt:0000000000000000000000000000000000000004",
           "swh:1:dir:0000000000000000000000000000000000000006",
           "swh:1:dir:0000000000000000000000000000000000000008",
           "swh:1:rev:0000000000000000000000000000000000000009",
           "swh:1:rel:0000000000000000000000000000000000000010",
           "swh:1:snp:0000000000000000000000000000000000000020",
           "swh:1:ori:0000000000000000000000000000000000000021"
         ));
 
     GraphTest.assertEqualsAnyOrder(expectedPaths, paths);
     assertSameNodesFromPaths(expectedPaths, nodes);
   }
 
   @Test
   public void forwardSnpToRev() {
     Graph graph = getGraph();
     SwhPID swhPID = new SwhPID("swh:1:snp:0000000000000000000000000000000000000020");
-    Endpoint endpoint = new Endpoint(graph, "forward", "snp:rev");
-    ArrayList<SwhPath> paths = (ArrayList) endpoint.visitPaths(new Endpoint.Input(swhPID)).result;
-    ArrayList<SwhPID> nodes = (ArrayList) endpoint.visitNodes(new Endpoint.Input(swhPID)).result;
+    Endpoint endpoint1 = new Endpoint(graph, "forward", "snp:rev");
+    ArrayList<SwhPath> paths = (ArrayList) endpoint1.visitPaths(new Endpoint.Input(swhPID)).result;
+    Endpoint endpoint2 = new Endpoint(graph, "forward", "snp:rev");
+    ArrayList<SwhPID> nodes = (ArrayList) endpoint2.visitNodes(new Endpoint.Input(swhPID)).result;
 
     ArrayList<SwhPath> expectedPaths = new ArrayList<SwhPath>();
     expectedPaths.add(
         new SwhPath(
           "swh:1:snp:0000000000000000000000000000000000000020",
           "swh:1:rev:0000000000000000000000000000000000000009"
         ));
 
     GraphTest.assertEqualsAnyOrder(expectedPaths, paths);
     assertSameNodesFromPaths(expectedPaths, nodes);
   }
 
   @Test
   public void forwardRelToRevRevToRev() {
     Graph graph = getGraph();
     SwhPID swhPID = new SwhPID("swh:1:rel:0000000000000000000000000000000000000010");
-    Endpoint endpoint = new Endpoint(graph, "forward", "rel:rev,rev:rev");
-    ArrayList<SwhPath> paths = (ArrayList) endpoint.visitPaths(new Endpoint.Input(swhPID)).result;
-    ArrayList<SwhPID> nodes = (ArrayList) endpoint.visitNodes(new Endpoint.Input(swhPID)).result;
+    Endpoint endpoint1 = new Endpoint(graph, "forward", "rel:rev,rev:rev");
+    ArrayList<SwhPath> paths = (ArrayList) endpoint1.visitPaths(new Endpoint.Input(swhPID)).result;
+    Endpoint endpoint2 = new Endpoint(graph, "forward", "rel:rev,rev:rev");
+    ArrayList<SwhPID> nodes = (ArrayList) endpoint2.visitNodes(new Endpoint.Input(swhPID)).result;
 
     ArrayList<SwhPath> expectedPaths = new ArrayList<SwhPath>();
     expectedPaths.add(
         new SwhPath(
           "swh:1:rel:0000000000000000000000000000000000000010",
           "swh:1:rev:0000000000000000000000000000000000000009",
           "swh:1:rev:0000000000000000000000000000000000000003"
         ));
 
     GraphTest.assertEqualsAnyOrder(expectedPaths, paths);
     assertSameNodesFromPaths(expectedPaths, nodes);
   }
 
   @Test
   public void forwardRevToAllDirToAll() {
     Graph graph = getGraph();
     SwhPID swhPID = new SwhPID("swh:1:rev:0000000000000000000000000000000000000013");
-    Endpoint endpoint = new Endpoint(graph, "forward", "rev:*,dir:*");
-    ArrayList<SwhPath> paths = (ArrayList) endpoint.visitPaths(new Endpoint.Input(swhPID)).result;
-    ArrayList<SwhPID> nodes = (ArrayList) endpoint.visitNodes(new Endpoint.Input(swhPID)).result;
+    Endpoint endpoint1 = new Endpoint(graph, "forward", "rev:*,dir:*");
+    ArrayList<SwhPath> paths = (ArrayList) endpoint1.visitPaths(new Endpoint.Input(swhPID)).result;
+    Endpoint endpoint2 = new Endpoint(graph, "forward", "rev:*,dir:*");
+    ArrayList<SwhPID> nodes = (ArrayList) endpoint2.visitNodes(new Endpoint.Input(swhPID)).result;
 
     ArrayList<SwhPath> expectedPaths = new ArrayList<SwhPath>();
     expectedPaths.add(
         new SwhPath(
           "swh:1:rev:0000000000000000000000000000000000000013",
           "swh:1:rev:0000000000000000000000000000000000000009",
           "swh:1:dir:0000000000000000000000000000000000000008",
           "swh:1:dir:0000000000000000000000000000000000000006",
           "swh:1:cnt:0000000000000000000000000000000000000005"
         ));
     expectedPaths.add(
         new SwhPath(
           "swh:1:rev:0000000000000000000000000000000000000013",
           "swh:1:dir:0000000000000000000000000000000000000012",
           "swh:1:dir:0000000000000000000000000000000000000008",
           "swh:1:dir:0000000000000000000000000000000000000006",
           "swh:1:cnt:0000000000000000000000000000000000000005"
         ));
     expectedPaths.add(
         new SwhPath(
           "swh:1:rev:0000000000000000000000000000000000000013",
           "swh:1:rev:0000000000000000000000000000000000000009",
           "swh:1:dir:0000000000000000000000000000000000000008",
           "swh:1:dir:0000000000000000000000000000000000000006",
           "swh:1:cnt:0000000000000000000000000000000000000004"
         ));
     expectedPaths.add(
         new SwhPath(
           "swh:1:rev:0000000000000000000000000000000000000013",
           "swh:1:dir:0000000000000000000000000000000000000012",
           "swh:1:dir:0000000000000000000000000000000000000008",
           "swh:1:dir:0000000000000000000000000000000000000006",
           "swh:1:cnt:0000000000000000000000000000000000000004"
         ));
     expectedPaths.add(
         new SwhPath(
           "swh:1:rev:0000000000000000000000000000000000000013",
           "swh:1:rev:0000000000000000000000000000000000000009",
           "swh:1:dir:0000000000000000000000000000000000000008",
           "swh:1:cnt:0000000000000000000000000000000000000007"
         ));
     expectedPaths.add(
         new SwhPath(
           "swh:1:rev:0000000000000000000000000000000000000013",
           "swh:1:dir:0000000000000000000000000000000000000012",
           "swh:1:dir:0000000000000000000000000000000000000008",
           "swh:1:cnt:0000000000000000000000000000000000000007"
         ));
     expectedPaths.add(
         new SwhPath(
           "swh:1:rev:0000000000000000000000000000000000000013",
           "swh:1:dir:0000000000000000000000000000000000000012",
           "swh:1:cnt:0000000000000000000000000000000000000011"
         ));
     expectedPaths.add(
         new SwhPath(
           "swh:1:rev:0000000000000000000000000000000000000013",
           "swh:1:rev:0000000000000000000000000000000000000009",
           "swh:1:rev:0000000000000000000000000000000000000003",
           "swh:1:dir:0000000000000000000000000000000000000002",
           "swh:1:cnt:0000000000000000000000000000000000000001"
         ));
     expectedPaths.add(
         new SwhPath(
           "swh:1:rev:0000000000000000000000000000000000000013",
           "swh:1:rev:0000000000000000000000000000000000000009",
           "swh:1:dir:0000000000000000000000000000000000000008",
           "swh:1:cnt:0000000000000000000000000000000000000001"
         ));
     expectedPaths.add(
         new SwhPath(
           "swh:1:rev:0000000000000000000000000000000000000013",
           "swh:1:dir:0000000000000000000000000000000000000012",
           "swh:1:dir:0000000000000000000000000000000000000008",
           "swh:1:cnt:0000000000000000000000000000000000000001"
         ));
 
     GraphTest.assertEqualsAnyOrder(expectedPaths, paths);
     assertSameNodesFromPaths(expectedPaths, nodes);
   }
 
   @Test
   public void forwardSnpToAllRevToAll() {
     Graph graph = getGraph();
     SwhPID swhPID = new SwhPID("swh:1:snp:0000000000000000000000000000000000000020");
-    Endpoint endpoint = new Endpoint(graph, "forward", "snp:*,rev:*");
-    ArrayList<SwhPath> paths = (ArrayList) endpoint.visitPaths(new Endpoint.Input(swhPID)).result;
-    ArrayList<SwhPID> nodes = (ArrayList) endpoint.visitNodes(new Endpoint.Input(swhPID)).result;
+    Endpoint endpoint1 = new Endpoint(graph, "forward", "snp:*,rev:*");
+    ArrayList<SwhPath> paths = (ArrayList) endpoint1.visitPaths(new Endpoint.Input(swhPID)).result;
+    Endpoint endpoint2 = new Endpoint(graph, "forward", "snp:*,rev:*");
+    ArrayList<SwhPID> nodes = (ArrayList) endpoint2.visitNodes(new Endpoint.Input(swhPID)).result;
 
     ArrayList<SwhPath> expectedPaths = new ArrayList<SwhPath>();
     expectedPaths.add(
         new SwhPath(
           "swh:1:snp:0000000000000000000000000000000000000020",
           "swh:1:rev:0000000000000000000000000000000000000009",
           "swh:1:rev:0000000000000000000000000000000000000003",
           "swh:1:dir:0000000000000000000000000000000000000002"
         ));
     expectedPaths.add(
         new SwhPath(
           "swh:1:snp:0000000000000000000000000000000000000020",
           "swh:1:rev:0000000000000000000000000000000000000009",
           "swh:1:dir:0000000000000000000000000000000000000008"
         ));
     expectedPaths.add(
         new SwhPath(
           "swh:1:snp:0000000000000000000000000000000000000020",
           "swh:1:rel:0000000000000000000000000000000000000010"
         ));
 
     GraphTest.assertEqualsAnyOrder(expectedPaths, paths);
     assertSameNodesFromPaths(expectedPaths, nodes);
   }
 
   @Test
   public void forwardNoEdges() {
     Graph graph = getGraph();
     SwhPID swhPID = new SwhPID("swh:1:snp:0000000000000000000000000000000000000020");
-    Endpoint endpoint = new Endpoint(graph, "forward", "");
-    ArrayList<SwhPath> paths = (ArrayList) endpoint.visitPaths(new Endpoint.Input(swhPID)).result;
-    ArrayList<SwhPID> nodes = (ArrayList) endpoint.visitNodes(new Endpoint.Input(swhPID)).result;
+    Endpoint endpoint1 = new Endpoint(graph, "forward", "");
+    ArrayList<SwhPath> paths = (ArrayList) endpoint1.visitPaths(new Endpoint.Input(swhPID)).result;
+    Endpoint endpoint2 = new Endpoint(graph, "forward", "");
+    ArrayList<SwhPID> nodes = (ArrayList) endpoint2.visitNodes(new Endpoint.Input(swhPID)).result;
 
     ArrayList<SwhPath> expectedPaths = new ArrayList<SwhPath>();
     expectedPaths.add(
         new SwhPath(
           "swh:1:snp:0000000000000000000000000000000000000020"
         ));
 
     GraphTest.assertEqualsAnyOrder(expectedPaths, paths);
     assertSameNodesFromPaths(expectedPaths, nodes);
   }
 
   @Test
   public void backwardRevToRevRevToRel() {
     Graph graph = getGraph();
     SwhPID swhPID = new SwhPID("swh:1:rev:0000000000000000000000000000000000000003");
-    Endpoint endpoint = new Endpoint(graph, "backward", "rev:rev,rev:rel");
-    ArrayList<SwhPath> paths = (ArrayList) endpoint.visitPaths(new Endpoint.Input(swhPID)).result;
-    ArrayList<SwhPID> nodes = (ArrayList) endpoint.visitNodes(new Endpoint.Input(swhPID)).result;
+    Endpoint endpoint1 = new Endpoint(graph, "backward", "rev:rev,rev:rel");
+    ArrayList<SwhPath> paths = (ArrayList) endpoint1.visitPaths(new Endpoint.Input(swhPID)).result;
+    Endpoint endpoint2 = new Endpoint(graph, "backward", "rev:rev,rev:rel");
+    ArrayList<SwhPID> nodes = (ArrayList) endpoint2.visitNodes(new Endpoint.Input(swhPID)).result;
 
     ArrayList<SwhPath> expectedPaths = new ArrayList<SwhPath>();
     expectedPaths.add(
         new SwhPath(
           "swh:1:rev:0000000000000000000000000000000000000003",
           "swh:1:rev:0000000000000000000000000000000000000009",
           "swh:1:rev:0000000000000000000000000000000000000013",
           "swh:1:rev:0000000000000000000000000000000000000018",
           "swh:1:rel:0000000000000000000000000000000000000019"
         ));
     expectedPaths.add(
         new SwhPath(
           "swh:1:rev:0000000000000000000000000000000000000003",
           "swh:1:rev:0000000000000000000000000000000000000009",
           "swh:1:rel:0000000000000000000000000000000000000010"
         ));
 
     GraphTest.assertEqualsAnyOrder(expectedPaths, paths);
     assertSameNodesFromPaths(expectedPaths, nodes);
   }
 
   @Test
   public void forwardFromRootNodesOnly() {
     Graph graph = getGraph();
     SwhPID swhPID = new SwhPID("swh:1:ori:0000000000000000000000000000000000000021");
     Endpoint endpoint = new Endpoint(graph, "forward", "*");
     ArrayList<SwhPID> nodes = (ArrayList) endpoint.visitNodes(new Endpoint.Input(swhPID)).result;
 
     ArrayList<SwhPID> expectedNodes = new ArrayList<SwhPID>();
     expectedNodes.add(new SwhPID("swh:1:ori:0000000000000000000000000000000000000021"));
     expectedNodes.add(new SwhPID("swh:1:snp:0000000000000000000000000000000000000020"));
     expectedNodes.add(new SwhPID("swh:1:rel:0000000000000000000000000000000000000010"));
     expectedNodes.add(new SwhPID("swh:1:rev:0000000000000000000000000000000000000009"));
     expectedNodes.add(new SwhPID("swh:1:rev:0000000000000000000000000000000000000003"));
     expectedNodes.add(new SwhPID("swh:1:dir:0000000000000000000000000000000000000002"));
     expectedNodes.add(new SwhPID("swh:1:cnt:0000000000000000000000000000000000000001"));
     expectedNodes.add(new SwhPID("swh:1:dir:0000000000000000000000000000000000000008"));
     expectedNodes.add(new SwhPID("swh:1:dir:0000000000000000000000000000000000000006"));
     expectedNodes.add(new SwhPID("swh:1:cnt:0000000000000000000000000000000000000004"));
     expectedNodes.add(new SwhPID("swh:1:cnt:0000000000000000000000000000000000000005"));
     expectedNodes.add(new SwhPID("swh:1:cnt:0000000000000000000000000000000000000007"));
 
     GraphTest.assertEqualsAnyOrder(expectedNodes, nodes);
   }
 
   @Test
   public void backwardRevToAllNodesOnly() {
     Graph graph = getGraph();
     SwhPID swhPID = new SwhPID("swh:1:rev:0000000000000000000000000000000000000003");
     Endpoint endpoint = new Endpoint(graph, "backward", "rev:*");
     ArrayList<SwhPID> nodes = (ArrayList) endpoint.visitNodes(new Endpoint.Input(swhPID)).result;
 
     ArrayList<SwhPID> expectedNodes = new ArrayList<SwhPID>();
     expectedNodes.add(new SwhPID("swh:1:rev:0000000000000000000000000000000000000003"));
     expectedNodes.add(new SwhPID("swh:1:rev:0000000000000000000000000000000000000009"));
     expectedNodes.add(new SwhPID("swh:1:snp:0000000000000000000000000000000000000020"));
     expectedNodes.add(new SwhPID("swh:1:rel:0000000000000000000000000000000000000010"));
     expectedNodes.add(new SwhPID("swh:1:rev:0000000000000000000000000000000000000013"));
     expectedNodes.add(new SwhPID("swh:1:rev:0000000000000000000000000000000000000018"));
     expectedNodes.add(new SwhPID("swh:1:rel:0000000000000000000000000000000000000019"));
 
     GraphTest.assertEqualsAnyOrder(expectedNodes, nodes);
   }
 }
diff --git a/java/server/src/test/java/org/softwareheritage/graph/WalkTest.java b/java/server/src/test/java/org/softwareheritage/graph/WalkTest.java
index 83c9b14..e8184f4 100644
--- a/java/server/src/test/java/org/softwareheritage/graph/WalkTest.java
+++ b/java/server/src/test/java/org/softwareheritage/graph/WalkTest.java
@@ -1,232 +1,239 @@
 package org.softwareheritage.graph;
 
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
 
 import org.junit.Assert;
 import org.junit.Test;
 
 import org.softwareheritage.graph.Endpoint;
 import org.softwareheritage.graph.Graph;
 import org.softwareheritage.graph.GraphTest;
 import org.softwareheritage.graph.SwhPID;
 import org.softwareheritage.graph.SwhPath;
 
 public class WalkTest extends GraphTest {
   @Test
   public void forwardRootToLeaf() {
     Graph graph = getGraph();
-    Endpoint endpoint = new Endpoint(graph, "forward", "*");
     SwhPID src = new SwhPID("swh:1:snp:0000000000000000000000000000000000000020");
     String dstFmt = "swh:1:cnt:0000000000000000000000000000000000000005";
 
     SwhPath solution1 =
       new SwhPath(
           "swh:1:snp:0000000000000000000000000000000000000020",
           "swh:1:rev:0000000000000000000000000000000000000009",
           "swh:1:dir:0000000000000000000000000000000000000008",
           "swh:1:dir:0000000000000000000000000000000000000006",
           "swh:1:cnt:0000000000000000000000000000000000000005"
       );
     SwhPath solution2 =
       new SwhPath(
           "swh:1:snp:0000000000000000000000000000000000000020",
           "swh:1:rel:0000000000000000000000000000000000000010",
           "swh:1:rev:0000000000000000000000000000000000000009",
           "swh:1:dir:0000000000000000000000000000000000000008",
           "swh:1:dir:0000000000000000000000000000000000000006",
           "swh:1:cnt:0000000000000000000000000000000000000005"
       );
 
-    SwhPath dfsPath = (SwhPath) endpoint.walk(new Endpoint.Input(src, dstFmt, "dfs")).result;
-    SwhPath bfsPath = (SwhPath) endpoint.walk(new Endpoint.Input(src, dstFmt, "bfs")).result;
+    Endpoint endpoint1 = new Endpoint(graph, "forward", "*");
+    SwhPath dfsPath = (SwhPath) endpoint1.walk(new Endpoint.Input(src, dstFmt, "dfs")).result;
+    Endpoint endpoint2 = new Endpoint(graph, "forward", "*");
+    SwhPath bfsPath = (SwhPath) endpoint2.walk(new Endpoint.Input(src, dstFmt, "bfs")).result;
 
     List<SwhPath> possibleSolutions = Arrays.asList(solution1, solution2);
     Assert.assertTrue(possibleSolutions.contains(dfsPath));
     Assert.assertTrue(possibleSolutions.contains(bfsPath));
   }
 
   @Test
   public void forwardLeafToLeaf() {
     Graph graph = getGraph();
-    Endpoint endpoint = new Endpoint(graph, "forward", "*");
     SwhPID src = new SwhPID("swh:1:cnt:0000000000000000000000000000000000000007");
     String dstFmt = "cnt";
 
     SwhPath expectedPath =
       new SwhPath(
           "swh:1:cnt:0000000000000000000000000000000000000007"
       );
 
-    SwhPath dfsPath = (SwhPath) endpoint.walk(new Endpoint.Input(src, dstFmt, "dfs")).result;
-    SwhPath bfsPath = (SwhPath) endpoint.walk(new Endpoint.Input(src, dstFmt, "bfs")).result;
+    Endpoint endpoint1 = new Endpoint(graph, "forward", "*");
+    SwhPath dfsPath = (SwhPath) endpoint1.walk(new Endpoint.Input(src, dstFmt, "dfs")).result;
+    Endpoint endpoint2 = new Endpoint(graph, "forward", "*");
+    SwhPath bfsPath = (SwhPath) endpoint2.walk(new Endpoint.Input(src, dstFmt, "bfs")).result;
 
     Assert.assertEquals(dfsPath, expectedPath);
     Assert.assertEquals(bfsPath, expectedPath);
   }
 
   @Test
   public void forwardRevToRev() {
     Graph graph = getGraph();
-    Endpoint endpoint = new Endpoint(graph, "forward", "rev:rev");
     SwhPID src = new SwhPID("swh:1:rev:0000000000000000000000000000000000000018");
     String dstFmt = "swh:1:rev:0000000000000000000000000000000000000003";
 
     SwhPath expectedPath =
       new SwhPath(
           "swh:1:rev:0000000000000000000000000000000000000018",
           "swh:1:rev:0000000000000000000000000000000000000013",
           "swh:1:rev:0000000000000000000000000000000000000009",
           "swh:1:rev:0000000000000000000000000000000000000003"
       );
 
-    SwhPath dfsPath = (SwhPath) endpoint.walk(new Endpoint.Input(src, dstFmt, "dfs")).result;
-    SwhPath bfsPath = (SwhPath) endpoint.walk(new Endpoint.Input(src, dstFmt, "bfs")).result;
+    Endpoint endpoint1 = new Endpoint(graph, "forward", "rev:rev");
+    SwhPath dfsPath = (SwhPath) endpoint1.walk(new Endpoint.Input(src, dstFmt, "dfs")).result;
+    Endpoint endpoint2 = new Endpoint(graph, "forward", "rev:rev");
+    SwhPath bfsPath = (SwhPath) endpoint2.walk(new Endpoint.Input(src, dstFmt, "bfs")).result;
 
     Assert.assertEquals(dfsPath, expectedPath);
     Assert.assertEquals(bfsPath, expectedPath);
   }
 
   @Test
   public void backwardRevToRev() {
     Graph graph = getGraph();
-    Endpoint endpoint = new Endpoint(graph, "backward", "rev:rev");
     SwhPID src = new SwhPID("swh:1:rev:0000000000000000000000000000000000000003");
     String dstFmt = "swh:1:rev:0000000000000000000000000000000000000018";
 
     SwhPath expectedPath =
       new SwhPath(
           "swh:1:rev:0000000000000000000000000000000000000003",
           "swh:1:rev:0000000000000000000000000000000000000009",
           "swh:1:rev:0000000000000000000000000000000000000013",
           "swh:1:rev:0000000000000000000000000000000000000018"
       );
 
-    SwhPath dfsPath = (SwhPath) endpoint.walk(new Endpoint.Input(src, dstFmt, "dfs")).result;
-    SwhPath bfsPath = (SwhPath) endpoint.walk(new Endpoint.Input(src, dstFmt, "bfs")).result;
+    Endpoint endpoint1 = new Endpoint(graph, "backward", "rev:rev");
+    SwhPath dfsPath = (SwhPath) endpoint1.walk(new Endpoint.Input(src, dstFmt, "dfs")).result;
+    Endpoint endpoint2 = new Endpoint(graph, "backward", "rev:rev");
+    SwhPath bfsPath = (SwhPath) endpoint2.walk(new Endpoint.Input(src, dstFmt, "bfs")).result;
 
     Assert.assertEquals(dfsPath, expectedPath);
     Assert.assertEquals(bfsPath, expectedPath);
   }
 
   @Test
   public void backwardCntToFirstSnp() {
     Graph graph = getGraph();
-    Endpoint endpoint = new Endpoint(graph, "backward", "*");
     SwhPID src = new SwhPID("swh:1:cnt:0000000000000000000000000000000000000001");
     String dstFmt = "snp";
 
     SwhPath solution1 =
       new SwhPath(
           "swh:1:cnt:0000000000000000000000000000000000000001",
           "swh:1:dir:0000000000000000000000000000000000000002",
           "swh:1:rev:0000000000000000000000000000000000000003",
           "swh:1:rev:0000000000000000000000000000000000000009",
           "swh:1:snp:0000000000000000000000000000000000000020"
       );
     SwhPath solution2 =
       new SwhPath(
           "swh:1:cnt:0000000000000000000000000000000000000001",
           "swh:1:dir:0000000000000000000000000000000000000002",
           "swh:1:rev:0000000000000000000000000000000000000003",
           "swh:1:rev:0000000000000000000000000000000000000009",
           "swh:1:rel:0000000000000000000000000000000000000010",
           "swh:1:snp:0000000000000000000000000000000000000020"
       );
     SwhPath solution3 =
       new SwhPath(
           "swh:1:cnt:0000000000000000000000000000000000000001",
           "swh:1:dir:0000000000000000000000000000000000000008",
           "swh:1:rev:0000000000000000000000000000000000000009",
           "swh:1:snp:0000000000000000000000000000000000000020"
       );
     SwhPath solution4 =
       new SwhPath(
           "swh:1:cnt:0000000000000000000000000000000000000001",
           "swh:1:dir:0000000000000000000000000000000000000008",
           "swh:1:rev:0000000000000000000000000000000000000009",
           "swh:1:rel:0000000000000000000000000000000000000010",
           "swh:1:snp:0000000000000000000000000000000000000020"
       );
 
-    SwhPath dfsPath = (SwhPath) endpoint.walk(new Endpoint.Input(src, dstFmt, "dfs")).result;
-    SwhPath bfsPath = (SwhPath) endpoint.walk(new Endpoint.Input(src, dstFmt, "bfs")).result;
+    Endpoint endpoint1 = new Endpoint(graph, "backward", "*");
+    SwhPath dfsPath = (SwhPath) endpoint1.walk(new Endpoint.Input(src, dstFmt, "dfs")).result;
+    Endpoint endpoint2 = new Endpoint(graph, "backward", "*");
+    SwhPath bfsPath = (SwhPath) endpoint2.walk(new Endpoint.Input(src, dstFmt, "bfs")).result;
 
     List<SwhPath> possibleSolutions = Arrays.asList(solution1, solution2, solution3, solution4);
     Assert.assertTrue(possibleSolutions.contains(dfsPath));
     Assert.assertTrue(possibleSolutions.contains(bfsPath));
   }
 
   @Test
   public void forwardRevToFirstCnt() {
     Graph graph = getGraph();
-    Endpoint endpoint = new Endpoint(graph, "forward", "rev:*,dir:*");
     SwhPID src = new SwhPID("swh:1:rev:0000000000000000000000000000000000000009");
     String dstFmt = "cnt";
 
     SwhPath solution1 =
       new SwhPath(
           "swh:1:rev:0000000000000000000000000000000000000009",
           "swh:1:dir:0000000000000000000000000000000000000008",
           "swh:1:cnt:0000000000000000000000000000000000000007"
       );
     SwhPath solution2 =
       new SwhPath(
           "swh:1:rev:0000000000000000000000000000000000000009",
           "swh:1:dir:0000000000000000000000000000000000000008",
           "swh:1:dir:0000000000000000000000000000000000000006",
           "swh:1:cnt:0000000000000000000000000000000000000005"
       );
     SwhPath solution3 =
       new SwhPath(
           "swh:1:rev:0000000000000000000000000000000000000009",
           "swh:1:dir:0000000000000000000000000000000000000008",
           "swh:1:dir:0000000000000000000000000000000000000006",
           "swh:1:cnt:0000000000000000000000000000000000000004"
       );
     SwhPath solution4 =
       new SwhPath(
           "swh:1:rev:0000000000000000000000000000000000000009",
           "swh:1:dir:0000000000000000000000000000000000000008",
           "swh:1:cnt:0000000000000000000000000000000000000001"
       );
     SwhPath solution5 =
       new SwhPath(
           "swh:1:rev:0000000000000000000000000000000000000009",
           "swh:1:rev:0000000000000000000000000000000000000003",
           "swh:1:dir:0000000000000000000000000000000000000002",
           "swh:1:cnt:0000000000000000000000000000000000000001"
       );
 
-    SwhPath dfsPath = (SwhPath) endpoint.walk(new Endpoint.Input(src, dstFmt, "dfs")).result;
-    SwhPath bfsPath = (SwhPath) endpoint.walk(new Endpoint.Input(src, dstFmt, "bfs")).result;
+    Endpoint endpoint1 = new Endpoint(graph, "forward", "rev:*,dir:*");
+    SwhPath dfsPath = (SwhPath) endpoint1.walk(new Endpoint.Input(src, dstFmt, "dfs")).result;
+    Endpoint endpoint2 = new Endpoint(graph, "forward", "rev:*,dir:*");
+    SwhPath bfsPath = (SwhPath) endpoint2.walk(new Endpoint.Input(src, dstFmt, "bfs")).result;
 
     List<SwhPath> possibleSolutions =
       Arrays.asList(solution1, solution2, solution3, solution4, solution5);
     Assert.assertTrue(possibleSolutions.contains(dfsPath));
     Assert.assertTrue(possibleSolutions.contains(bfsPath));
   }
 
   @Test
   public void backwardDirToFirstRel() {
     Graph graph = getGraph();
-    Endpoint endpoint = new Endpoint(graph, "backward", "dir:dir,dir:rev,rev:*");
     SwhPID src = new SwhPID("swh:1:dir:0000000000000000000000000000000000000016");
     String dstFmt = "rel";
 
     SwhPath expectedPath =
       new SwhPath(
           "swh:1:dir:0000000000000000000000000000000000000016",
           "swh:1:dir:0000000000000000000000000000000000000017",
           "swh:1:rev:0000000000000000000000000000000000000018",
           "swh:1:rel:0000000000000000000000000000000000000019"
       );
 
-    SwhPath dfsPath = (SwhPath) endpoint.walk(new Endpoint.Input(src, dstFmt, "dfs")).result;
-    SwhPath bfsPath = (SwhPath) endpoint.walk(new Endpoint.Input(src, dstFmt, "bfs")).result;
+    Endpoint endpoint1 = new Endpoint(graph, "backward", "dir:dir,dir:rev,rev:*");
+    SwhPath dfsPath = (SwhPath) endpoint1.walk(new Endpoint.Input(src, dstFmt, "dfs")).result;
+    Endpoint endpoint2 = new Endpoint(graph, "backward", "dir:dir,dir:rev,rev:*");
+    SwhPath bfsPath = (SwhPath) endpoint2.walk(new Endpoint.Input(src, dstFmt, "bfs")).result;
 
     Assert.assertEquals(dfsPath, expectedPath);
     Assert.assertEquals(bfsPath, expectedPath);
   }
 }