diff --git a/java/src/test/java/org/softwareheritage/graph/rpc/FindPathBetweenTest.java b/java/src/test/java/org/softwareheritage/graph/rpc/FindPathBetweenTest.java
index 0e288bc..9e8f33c 100644
--- a/java/src/test/java/org/softwareheritage/graph/rpc/FindPathBetweenTest.java
+++ b/java/src/test/java/org/softwareheritage/graph/rpc/FindPathBetweenTest.java
@@ -1,42 +1,99 @@
 package org.softwareheritage.graph.rpc;
 
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
 import org.softwareheritage.graph.SWHID;
 
 import java.util.ArrayList;
 import java.util.List;
 
 public class FindPathBetweenTest extends TraversalServiceTest {
     private FindPathBetweenRequest.Builder getRequestBuilder(SWHID src, SWHID dst) {
         return FindPathBetweenRequest.newBuilder().addSrc(src.toString()).addDst(dst.toString());
     }
 
+    // Test path between ori 1 and cnt 4 (forward graph)
     @Test
     public void forwardRootToLeaf() {
         ArrayList<SWHID> actual = getSWHIDs(
                 client.findPathBetween(getRequestBuilder(new SWHID(TEST_ORIGIN_ID), fakeSWHID("cnt", 4)).build()));
         List<SWHID> expected = List.of(new SWHID(TEST_ORIGIN_ID), fakeSWHID("snp", 20), fakeSWHID("rev", 9),
                 fakeSWHID("dir", 8), fakeSWHID("dir", 6), fakeSWHID("cnt", 4));
         Assertions.assertEquals(expected, actual);
     }
 
+    // Test path between rev 18 and rev 3 (forward graph)
     @Test
     public void forwardRevToRev() {
         ArrayList<SWHID> actual = getSWHIDs(
                 client.findPathBetween(getRequestBuilder(fakeSWHID("rev", 18), fakeSWHID("rev", 3)).build()));
         List<SWHID> expected = List.of(fakeSWHID("rev", 18), fakeSWHID("rev", 13), fakeSWHID("rev", 9),
                 fakeSWHID("rev", 3));
         Assertions.assertEquals(expected, actual);
     }
 
+    // Test path between rev 3 and rev 18 (backward graph)
     @Test
     public void backwardRevToRev() {
         ArrayList<SWHID> actual = getSWHIDs(
                 client.findPathBetween(getRequestBuilder(fakeSWHID("rev", 3), fakeSWHID("rev", 18))
                         .setDirection(GraphDirection.BACKWARD).build()));
         List<SWHID> expected = List.of(fakeSWHID("rev", 3), fakeSWHID("rev", 9), fakeSWHID("rev", 13),
                 fakeSWHID("rev", 18));
         Assertions.assertEquals(expected, actual);
     }
+
+    // Test path between cnt 4 and itself (forward graph)
+    @Test
+    public void forwardCntToItself() {
+        ArrayList<SWHID> actual = getSWHIDs(
+                client.findPathBetween(getRequestBuilder(fakeSWHID("cnt", 4), fakeSWHID("cnt", 4)).build()));
+        List<SWHID> expected = List.of(fakeSWHID("cnt", 4));
+        Assertions.assertEquals(expected, actual);
+    }
+
+    // Start from ori and rel 19 and find cnt 14 or cnt 7 (forward graph)
+    @Test
+    public void forwardMultipleSourcesDest() {
+        ArrayList<SWHID> actual = getSWHIDs(
+                client.findPathBetween(getRequestBuilder(fakeSWHID("rel", 19), fakeSWHID("cnt", 14))
+                        .addSrc(TEST_ORIGIN_ID).addDst(fakeSWHID("cnt", 7).toString()).build()));
+        List<SWHID> expected = List.of(fakeSWHID("rel", 19), fakeSWHID("rev", 18), fakeSWHID("dir", 17),
+                fakeSWHID("cnt", 14));
+    }
+
+    // Start from cnt 4 and cnt 11 and find rev 13 or rev 9 (backward graph)
+    @Test
+    public void backwardMultipleSourcesDest() {
+        ArrayList<SWHID> actual = getSWHIDs(client.findPathBetween(
+                getRequestBuilder(fakeSWHID("cnt", 4), fakeSWHID("rev", 13)).setDirection(GraphDirection.BACKWARD)
+                        .addSrc(fakeSWHID("cnt", 11).toString()).addDst(fakeSWHID("rev", 9).toString()).build()));
+        List<SWHID> expected = List.of(fakeSWHID("cnt", 11), fakeSWHID("dir", 12), fakeSWHID("rev", 13));
+        Assertions.assertEquals(expected, actual);
+    }
+
+    // Start from all directories and find the origin (backward graph)
+    @Test
+    public void backwardMultipleSourcesAllDirToOri() {
+        ArrayList<SWHID> actual = getSWHIDs(
+                client.findPathBetween(getRequestBuilder(fakeSWHID("dir", 2), new SWHID(TEST_ORIGIN_ID))
+                        .addSrc(fakeSWHID("dir", 6).toString()).addSrc(fakeSWHID("dir", 8).toString())
+                        .addSrc(fakeSWHID("dir", 12).toString()).addSrc(fakeSWHID("dir", 16).toString())
+                        .addSrc(fakeSWHID("dir", 17).toString()).setDirection(GraphDirection.BACKWARD).build()));
+        List<SWHID> expected = List.of(fakeSWHID("dir", 8), fakeSWHID("rev", 9), fakeSWHID("snp", 20),
+                new SWHID(TEST_ORIGIN_ID));
+        Assertions.assertEquals(expected, actual);
+    }
+
+    // Start from cnt 4 and find any rev (backward graph)
+    @Test
+    public void backwardCntToAnyRev() {
+        ArrayList<SWHID> actual = getSWHIDs(
+                client.findPathBetween(getRequestBuilder(fakeSWHID("cnt", 4), fakeSWHID("rev", 3))
+                        .addDst(fakeSWHID("rev", 9).toString()).addDst(fakeSWHID("rev", 13).toString())
+                        .addDst(fakeSWHID("rev", 18).toString()).setDirection(GraphDirection.BACKWARD).build()));
+        List<SWHID> expected = List.of(fakeSWHID("cnt", 4), fakeSWHID("dir", 6), fakeSWHID("dir", 8),
+                fakeSWHID("rev", 9));
+        Assertions.assertEquals(expected, actual);
+    }
 }
diff --git a/java/src/test/java/org/softwareheritage/graph/rpc/FindPathToTest.java b/java/src/test/java/org/softwareheritage/graph/rpc/FindPathToTest.java
index 182f005..bbcace2 100644
--- a/java/src/test/java/org/softwareheritage/graph/rpc/FindPathToTest.java
+++ b/java/src/test/java/org/softwareheritage/graph/rpc/FindPathToTest.java
@@ -1,48 +1,82 @@
 package org.softwareheritage.graph.rpc;
 
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
 import org.softwareheritage.graph.SWHID;
 
 import java.util.ArrayList;
 import java.util.List;
 
 public class FindPathToTest extends TraversalServiceTest {
     private FindPathToRequest.Builder getRequestBuilder(SWHID src, String allowedNodes) {
         return FindPathToRequest.newBuilder().addSrc(src.toString())
                 .setTarget(NodeFilter.newBuilder().setTypes(allowedNodes).build());
     }
 
+    // Test path between ori 1 and any dir (forward graph)
     @Test
     public void forwardOriToFirstDir() {
         ArrayList<SWHID> actual = getSWHIDs(
                 client.findPathTo(getRequestBuilder(new SWHID(TEST_ORIGIN_ID), "dir").build()));
         List<SWHID> expected = List.of(new SWHID(TEST_ORIGIN_ID), fakeSWHID("snp", 20), fakeSWHID("rev", 9),
                 fakeSWHID("dir", 8));
         Assertions.assertEquals(expected, actual);
     }
 
+    // Test path between rel 19 and any cnt (forward graph)
     @Test
     public void forwardRelToFirstCnt() {
         ArrayList<SWHID> actual = getSWHIDs(client.findPathTo(getRequestBuilder(fakeSWHID("rel", 19), "cnt").build()));
         List<SWHID> expected = List.of(fakeSWHID("rel", 19), fakeSWHID("rev", 18), fakeSWHID("dir", 17),
                 fakeSWHID("cnt", 14));
         Assertions.assertEquals(expected, actual);
     }
 
+    // Test path between dir 16 and any rel (backward graph)
     @Test
     public void backwardDirToFirstRel() {
         ArrayList<SWHID> actual = getSWHIDs(client.findPathTo(
                 getRequestBuilder(fakeSWHID("dir", 16), "rel").setDirection(GraphDirection.BACKWARD).build()));
         List<SWHID> expected = List.of(fakeSWHID("dir", 16), fakeSWHID("dir", 17), fakeSWHID("rev", 18),
                 fakeSWHID("rel", 19));
         Assertions.assertEquals(expected, actual);
     }
 
+    // Test path between cnt 4 and itself (forward graph)
     @Test
     public void forwardCntToItself() {
         ArrayList<SWHID> actual = getSWHIDs(client.findPathTo(getRequestBuilder(fakeSWHID("cnt", 4), "cnt").build()));
         List<SWHID> expected = List.of(fakeSWHID("cnt", 4));
         Assertions.assertEquals(expected, actual);
     }
+
+    // Start from ori and rel 19 and find any cnt (forward graph)
+    @Test
+    public void forwardMultipleSources() {
+        ArrayList<SWHID> actual = getSWHIDs(
+                client.findPathTo(getRequestBuilder(fakeSWHID("rel", 19), "cnt").addSrc(TEST_ORIGIN_ID).build()));
+        List<SWHID> expected = List.of(fakeSWHID("rel", 19), fakeSWHID("rev", 18), fakeSWHID("dir", 17),
+                fakeSWHID("cnt", 14));
+    }
+
+    // Start from cnt 4 and cnt 11 and find any rev (backward graph)
+    @Test
+    public void backwardMultipleSources() {
+        ArrayList<SWHID> actual = getSWHIDs(client.findPathTo(getRequestBuilder(fakeSWHID("cnt", 4), "rev")
+                .addSrc(fakeSWHID("cnt", 11).toString()).setDirection(GraphDirection.BACKWARD).build()));
+        List<SWHID> expected = List.of(fakeSWHID("cnt", 11), fakeSWHID("dir", 12), fakeSWHID("rev", 13));
+        Assertions.assertEquals(expected, actual);
+    }
+
+    // Start from all directories and find any origin (backward graph)
+    @Test
+    public void backwardMultipleSourcesAllDirToOri() {
+        ArrayList<SWHID> actual = getSWHIDs(client.findPathTo(getRequestBuilder(fakeSWHID("dir", 2), "ori")
+                .addSrc(fakeSWHID("dir", 6).toString()).addSrc(fakeSWHID("dir", 8).toString())
+                .addSrc(fakeSWHID("dir", 12).toString()).addSrc(fakeSWHID("dir", 16).toString())
+                .addSrc(fakeSWHID("dir", 17).toString()).setDirection(GraphDirection.BACKWARD).build()));
+        List<SWHID> expected = List.of(fakeSWHID("dir", 8), fakeSWHID("rev", 9), fakeSWHID("snp", 20),
+                new SWHID(TEST_ORIGIN_ID));
+        Assertions.assertEquals(expected, actual);
+    }
 }
diff --git a/java/src/test/java/org/softwareheritage/graph/rpc/TraverseNodesTest.java b/java/src/test/java/org/softwareheritage/graph/rpc/TraverseNodesTest.java
index 0554ae1..2dc34fd 100644
--- a/java/src/test/java/org/softwareheritage/graph/rpc/TraverseNodesTest.java
+++ b/java/src/test/java/org/softwareheritage/graph/rpc/TraverseNodesTest.java
@@ -1,149 +1,167 @@
 package org.softwareheritage.graph.rpc;
 
 import org.junit.jupiter.api.Test;
 import org.softwareheritage.graph.GraphTest;
 import org.softwareheritage.graph.SWHID;
 
 import java.util.ArrayList;
 import java.util.List;
 
 public class TraverseNodesTest extends TraversalServiceTest {
     private TraversalRequest.Builder getTraversalRequestBuilder(SWHID src) {
         return TraversalRequest.newBuilder().addSrc(src.toString());
     }
 
     @Test
     public void forwardFromRoot() {
         ArrayList<SWHID> actual = getSWHIDs(
                 client.traverse(getTraversalRequestBuilder(new SWHID(TEST_ORIGIN_ID)).build()));
         List<SWHID> expected = List.of(fakeSWHID("cnt", 1), fakeSWHID("cnt", 4), fakeSWHID("cnt", 5),
                 fakeSWHID("cnt", 7), fakeSWHID("dir", 2), fakeSWHID("dir", 6), fakeSWHID("dir", 8),
                 fakeSWHID("rel", 10), fakeSWHID("rev", 3), fakeSWHID("rev", 9), fakeSWHID("snp", 20),
                 new SWHID(TEST_ORIGIN_ID));
         GraphTest.assertEqualsAnyOrder(expected, actual);
     }
 
     @Test
     public void forwardFromMiddle() {
         ArrayList<SWHID> actual = getSWHIDs(client.traverse(getTraversalRequestBuilder(fakeSWHID("dir", 12)).build()));
         List<SWHID> expected = List.of(fakeSWHID("cnt", 1), fakeSWHID("cnt", 4), fakeSWHID("cnt", 5),
                 fakeSWHID("cnt", 7), fakeSWHID("cnt", 11), fakeSWHID("dir", 6), fakeSWHID("dir", 8),
                 fakeSWHID("dir", 12));
         GraphTest.assertEqualsAnyOrder(expected, actual);
     }
 
     @Test
     public void forwardRelRev() {
         ArrayList<SWHID> actual = getSWHIDs(
                 client.traverse(getTraversalRequestBuilder(fakeSWHID("rel", 10)).setEdges("rel:rev,rev:rev").build()));
         List<SWHID> expected = List.of(fakeSWHID("rel", 10), fakeSWHID("rev", 9), fakeSWHID("rev", 3));
         GraphTest.assertEqualsAnyOrder(expected, actual);
     }
 
     @Test
     public void forwardFilterReturnedNodesDir() {
         ArrayList<SWHID> actual = getSWHIDs(client.traverse(getTraversalRequestBuilder(fakeSWHID("rel", 10))
                 .setReturnNodes(NodeFilter.newBuilder().setTypes("dir").build()).build()));
         List<SWHID> expected = List.of(fakeSWHID("dir", 2), fakeSWHID("dir", 8), fakeSWHID("dir", 6));
         GraphTest.assertEqualsAnyOrder(expected, actual);
     }
 
     @Test
     public void backwardFromRoot() {
         ArrayList<SWHID> actual = getSWHIDs(client.traverse(
                 getTraversalRequestBuilder(new SWHID(TEST_ORIGIN_ID)).setDirection(GraphDirection.BACKWARD).build()));
         List<SWHID> expected = List.of(new SWHID(TEST_ORIGIN_ID));
         GraphTest.assertEqualsAnyOrder(expected, actual);
     }
 
     @Test
     public void backwardFromMiddle() {
         ArrayList<SWHID> actual = getSWHIDs(client.traverse(
                 getTraversalRequestBuilder(fakeSWHID("dir", 12)).setDirection(GraphDirection.BACKWARD).build()));
         List<SWHID> expected = List.of(fakeSWHID("dir", 12), fakeSWHID("rel", 19), fakeSWHID("rev", 13),
                 fakeSWHID("rev", 18));
         GraphTest.assertEqualsAnyOrder(expected, actual);
     }
 
     @Test
     public void backwardFromLeaf() {
         ArrayList<SWHID> actual = getSWHIDs(client.traverse(
                 getTraversalRequestBuilder(fakeSWHID("cnt", 4)).setDirection(GraphDirection.BACKWARD).build()));
         List<SWHID> expected = List.of(new SWHID(TEST_ORIGIN_ID), fakeSWHID("cnt", 4), fakeSWHID("dir", 6),
                 fakeSWHID("dir", 8), fakeSWHID("dir", 12), fakeSWHID("rel", 10), fakeSWHID("rel", 19),
                 fakeSWHID("rev", 9), fakeSWHID("rev", 13), fakeSWHID("rev", 18), fakeSWHID("snp", 20));
         GraphTest.assertEqualsAnyOrder(expected, actual);
     }
 
     @Test
     public void forwardSnpToRev() {
         ArrayList<SWHID> actual = getSWHIDs(
                 client.traverse(getTraversalRequestBuilder(fakeSWHID("snp", 20)).setEdges("snp:rev").build()));
         List<SWHID> expected = List.of(fakeSWHID("rev", 9), fakeSWHID("snp", 20));
         GraphTest.assertEqualsAnyOrder(expected, actual);
     }
 
     @Test
     public void forwardRelToRevRevToRev() {
         ArrayList<SWHID> actual = getSWHIDs(
                 client.traverse(getTraversalRequestBuilder(fakeSWHID("rel", 10)).setEdges("rel:rev,rev:rev").build()));
         List<SWHID> expected = List.of(fakeSWHID("rel", 10), fakeSWHID("rev", 3), fakeSWHID("rev", 9));
         GraphTest.assertEqualsAnyOrder(expected, actual);
     }
 
     @Test
     public void forwardRevToAllDirToAll() {
         ArrayList<SWHID> actual = getSWHIDs(
                 client.traverse(getTraversalRequestBuilder(fakeSWHID("rev", 13)).setEdges("rev:*,dir:*").build()));
         List<SWHID> expected = List.of(fakeSWHID("cnt", 1), fakeSWHID("cnt", 4), fakeSWHID("cnt", 5),
                 fakeSWHID("cnt", 7), fakeSWHID("cnt", 11), fakeSWHID("dir", 2), fakeSWHID("dir", 6),
                 fakeSWHID("dir", 8), fakeSWHID("dir", 12), fakeSWHID("rev", 3), fakeSWHID("rev", 9),
                 fakeSWHID("rev", 13));
         GraphTest.assertEqualsAnyOrder(expected, actual);
     }
 
     @Test
     public void forwardSnpToAllRevToAll() {
         ArrayList<SWHID> actual = getSWHIDs(
                 client.traverse(getTraversalRequestBuilder(fakeSWHID("snp", 20)).setEdges("snp:*,rev:*").build()));
         List<SWHID> expected = List.of(fakeSWHID("dir", 2), fakeSWHID("dir", 8), fakeSWHID("rel", 10),
                 fakeSWHID("rev", 3), fakeSWHID("rev", 9), fakeSWHID("snp", 20));
         GraphTest.assertEqualsAnyOrder(expected, actual);
     }
 
     @Test
     public void forwardNoEdges() {
         ArrayList<SWHID> actual = getSWHIDs(
                 client.traverse(getTraversalRequestBuilder(fakeSWHID("snp", 20)).setEdges("").build()));
         List<SWHID> expected = List.of(fakeSWHID("snp", 20));
         GraphTest.assertEqualsAnyOrder(expected, actual);
     }
 
     @Test
     public void backwardRevToRevRevToRel() {
         ArrayList<SWHID> actual = getSWHIDs(client.traverse(getTraversalRequestBuilder(fakeSWHID("rev", 3))
                 .setEdges("rev:rev,rev:rel").setDirection(GraphDirection.BACKWARD).build()));
         List<SWHID> expected = List.of(fakeSWHID("rel", 10), fakeSWHID("rel", 19), fakeSWHID("rev", 3),
                 fakeSWHID("rev", 9), fakeSWHID("rev", 13), fakeSWHID("rev", 18));
         GraphTest.assertEqualsAnyOrder(expected, actual);
     }
 
     @Test
     public void forwardFromRootNodesOnly() {
         ArrayList<SWHID> actual = getSWHIDs(
                 client.traverse(getTraversalRequestBuilder(new SWHID(TEST_ORIGIN_ID)).build()));
         List<SWHID> expected = List.of(new SWHID(TEST_ORIGIN_ID), fakeSWHID("cnt", 1), fakeSWHID("cnt", 4),
                 fakeSWHID("cnt", 5), fakeSWHID("cnt", 7), fakeSWHID("dir", 2), fakeSWHID("dir", 6), fakeSWHID("dir", 8),
                 fakeSWHID("rel", 10), fakeSWHID("rev", 3), fakeSWHID("rev", 9), fakeSWHID("snp", 20));
         GraphTest.assertEqualsAnyOrder(expected, actual);
     }
 
     @Test
     public void backwardRevToAllNodesOnly() {
         ArrayList<SWHID> actual = getSWHIDs(client.traverse(getTraversalRequestBuilder(fakeSWHID("rev", 3))
                 .setDirection(GraphDirection.BACKWARD).setEdges("rev:*").build()));
         List<SWHID> expected = List.of(fakeSWHID("rel", 10), fakeSWHID("rel", 19), fakeSWHID("rev", 3),
                 fakeSWHID("rev", 9), fakeSWHID("rev", 13), fakeSWHID("rev", 18), fakeSWHID("snp", 20));
         GraphTest.assertEqualsAnyOrder(expected, actual);
     }
+
+    @Test
+    public void forwardMultipleSources() {
+        ArrayList<SWHID> actual = getSWHIDs(client.traverse(getTraversalRequestBuilder(fakeSWHID("snp", 20))
+                .addSrc(fakeSWHID("rel", 19).toString()).setMaxDepth(1).build()));
+        List<SWHID> expected = List.of(fakeSWHID("snp", 20), fakeSWHID("rel", 19), fakeSWHID("rel", 10),
+                fakeSWHID("rev", 9), fakeSWHID("rev", 18));
+        GraphTest.assertEqualsAnyOrder(expected, actual);
+    }
+
+    @Test
+    public void backwardMultipleSources() {
+        ArrayList<SWHID> actual = getSWHIDs(client.traverse(getTraversalRequestBuilder(fakeSWHID("cnt", 5))
+                .addSrc(fakeSWHID("dir", 16).toString()).setMaxDepth(2).setDirection(GraphDirection.BACKWARD).build()));
+        List<SWHID> expected = List.of(fakeSWHID("cnt", 5), fakeSWHID("dir", 16), fakeSWHID("dir", 6),
+                fakeSWHID("dir", 8), fakeSWHID("dir", 17), fakeSWHID("rev", 18));
+        GraphTest.assertEqualsAnyOrder(expected, actual);
+    }
 }