diff --git a/java/pom.xml b/java/pom.xml
index c0ec690..bed537c 100644
--- a/java/pom.xml
+++ b/java/pom.xml
@@ -1,225 +1,235 @@
 <?xml version="1.0" encoding="UTF-8"?>
 
 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
   <modelVersion>4.0.0</modelVersion>
 
   <groupId>org.softwareheritage.graph</groupId>
   <artifactId>swh-graph</artifactId>
   <version>${git.closest.tag.name}</version>
 
   <name>swh-graph</name>
   <url>https://forge.softwareheritage.org/source/swh-graph/</url>
 
   <properties>
     <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
     <maven.compiler.release>11</maven.compiler.release>
   </properties>
 
   <dependencies>
     <dependency>
       <groupId>ch.qos.logback</groupId>
       <artifactId>logback-classic</artifactId>
       <version>1.2.3</version>
     </dependency>
     <dependency>
-      <groupId>junit</groupId>
-      <artifactId>junit</artifactId>
-      <version>4.11</version>
+      <groupId>org.junit.jupiter</groupId>
+      <artifactId>junit-jupiter-api</artifactId>
+      <version>5.7.0</version>
       <scope>test</scope>
     </dependency>
+    <dependency>
+        <groupId>org.junit.jupiter</groupId>
+        <artifactId>junit-jupiter-engine</artifactId>
+        <version>5.7.0</version>
+        <scope>test</scope>
+    </dependency>
     <dependency>
       <groupId>org.hamcrest</groupId>
       <artifactId>hamcrest</artifactId>
       <version>2.1</version>
       <scope>test</scope>
     </dependency>
     <dependency>
       <groupId>io.javalin</groupId>
       <artifactId>javalin</artifactId>
       <version>3.0.0</version>
     </dependency>
     <dependency>
       <groupId>org.slf4j</groupId>
       <artifactId>slf4j-simple</artifactId>
       <version>1.7.26</version>
     </dependency>
     <dependency>
       <groupId>com.fasterxml.jackson.core</groupId>
       <artifactId>jackson-databind</artifactId>
       <version>2.9.8</version>
     </dependency>
     <dependency>
       <groupId>it.unimi.dsi</groupId>
       <artifactId>webgraph-big</artifactId>
       <version>3.6.0</version>
     </dependency>
     <dependency>
       <groupId>it.unimi.dsi</groupId>
       <artifactId>fastutil</artifactId>
       <version>8.4.1</version>
     </dependency>
     <dependency>
       <groupId>it.unimi.dsi</groupId>
       <artifactId>law</artifactId>
       <version>2.6.2</version>
       <exclusions>
         <exclusion>
           <groupId>org.apache.hadoop</groupId>
           <artifactId>hadoop-common</artifactId>
         </exclusion>
         <exclusion>
           <groupId>org.umlgraph</groupId>
           <artifactId>umlgraph</artifactId>
         </exclusion>
         <exclusion>
           <groupId>org.eclipse.jetty.aggregate</groupId>
           <artifactId>jetty-all</artifactId>
         </exclusion>
         <exclusion>
           <groupId>it.unimi.di</groupId>
           <artifactId>mg4j</artifactId>
         </exclusion>
         <exclusion>
           <groupId>it.unimi.di</groupId>
           <artifactId>mg4j-big</artifactId>
         </exclusion>
       </exclusions>
     </dependency>
     <dependency>
       <groupId>com.martiansoftware</groupId>
       <artifactId>jsap</artifactId>
       <version>2.1</version>
     </dependency>
     <dependency>
       <groupId>net.sf.py4j</groupId>
       <artifactId>py4j</artifactId>
       <version>0.10.8.1</version>
     </dependency>
     <dependency>
       <groupId>commons-codec</groupId>
       <artifactId>commons-codec</artifactId>
       <version>1.11</version>
     </dependency>
   </dependencies>
 
   <build>
     <pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
       <plugins>
         <!-- clean lifecycle, see https://maven.apache.org/ref/current/maven-core/lifecycles.html#clean_Lifecycle -->
         <plugin>
           <artifactId>maven-clean-plugin</artifactId>
           <version>3.1.0</version>
         </plugin>
         <!-- default lifecycle, jar packaging: see https://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_jar_packaging -->
         <plugin>
           <artifactId>maven-resources-plugin</artifactId>
           <version>3.0.2</version>
         </plugin>
         <plugin>
           <artifactId>maven-compiler-plugin</artifactId>
           <version>3.8.0</version>
           <configuration>
             <source>11</source>
             <target>11</target>
             <compilerArgs>
               <arg>-verbose</arg>
               <arg>-Xlint:all</arg>
             </compilerArgs>
           </configuration>
         </plugin>
         <plugin>
           <artifactId>maven-surefire-plugin</artifactId>
-          <version>2.22.1</version>
+          <version>2.22.2</version>
+        </plugin>
+        <plugin>
+            <artifactId>maven-failsafe-plugin</artifactId>
+            <version>2.22.2</version>
         </plugin>
         <plugin>
           <artifactId>maven-jar-plugin</artifactId>
           <version>3.0.2</version>
         </plugin>
         <plugin>
           <artifactId>maven-install-plugin</artifactId>
           <version>2.5.2</version>
         </plugin>
         <plugin>
           <artifactId>maven-deploy-plugin</artifactId>
           <version>2.8.2</version>
         </plugin>
         <!-- site lifecycle, see https://maven.apache.org/ref/current/maven-core/lifecycles.html#site_Lifecycle -->
         <plugin>
           <artifactId>maven-site-plugin</artifactId>
           <version>3.7.1</version>
         </plugin>
         <plugin>
           <artifactId>maven-project-info-reports-plugin</artifactId>
           <version>3.0.0</version>
         </plugin>
         <plugin>
           <artifactId>maven-assembly-plugin</artifactId>
           <version>3.3.0</version>
           <configuration>
             <archive>
               <manifest>
                 <mainClass>org.softwareheritage.graph.server.App</mainClass>
               </manifest>
             </archive>
             <descriptorRefs>
               <descriptorRef>jar-with-dependencies</descriptorRef>
             </descriptorRefs>
             <appendAssemblyId>false</appendAssemblyId>
           </configuration>
           <executions>
             <execution>
               <id>make-assembly</id> <!-- this is used for inheritance merges -->
               <phase>package</phase> <!-- bind to the packaging phase -->
               <goals>
                 <goal>single</goal>
               </goals>
             </execution>
           </executions>
         </plugin>
       </plugins>
     </pluginManagement>
     <plugins>
       <plugin>
         <groupId>pl.project13.maven</groupId>
         <artifactId>git-commit-id-plugin</artifactId>
         <version>3.0.1</version>
         <executions>
           <execution>
             <id>get-the-git-infos</id>
             <goals>
               <goal>revision</goal>
             </goals>
             <phase>initialize</phase>
           </execution>
         </executions>
         <configuration>
           <verbose>true</verbose>
           <offline>true</offline>
           <useNativeGit>true</useNativeGit>
           <gitDescribe>
             <always>true</always>
             <match>v*</match>
           </gitDescribe>
           <replacementProperties>
             <replacementProperty>
               <property>git.closest.tag.name</property>
               <token>^v</token>
               <value></value>
               <regex>true</regex>
             </replacementProperty>
           </replacementProperties>
         </configuration>
       </plugin>
     </plugins>
   </build>
   <reporting>
     <plugins>
       <plugin>
         <groupId>org.apache.maven.plugins</groupId>
         <artifactId>maven-javadoc-plugin</artifactId>
         <version>3.1.1</version>
       </plugin>
     </plugins>
   </reporting>
 </project>
diff --git a/java/src/test/java/org/softwareheritage/graph/AllowedEdgesTest.java b/java/src/test/java/org/softwareheritage/graph/AllowedEdgesTest.java
index 506a519..7edb19d 100644
--- a/java/src/test/java/org/softwareheritage/graph/AllowedEdgesTest.java
+++ b/java/src/test/java/org/softwareheritage/graph/AllowedEdgesTest.java
@@ -1,112 +1,112 @@
 package org.softwareheritage.graph;
 
-import java.util.ArrayList;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
 
-import org.junit.Test;
-import org.junit.Assert;
+import java.util.ArrayList;
 
 
 public class AllowedEdgesTest extends GraphTest {
     static class EdgeType {
         Node.Type src;
         Node.Type dst;
 
         public EdgeType(Node.Type src, Node.Type dst) {
             this.src = src;
             this.dst = dst;
         }
 
         @Override
         public boolean equals(Object otherObj) {
             if (otherObj == this) return true;
             if (!(otherObj instanceof EdgeType)) return false;
 
             EdgeType other = (EdgeType) otherObj;
             return src == other.src && dst == other.dst;
         }
     }
 
     void assertEdgeRestriction(AllowedEdges edges, ArrayList<EdgeType> expectedAllowed) {
         Node.Type[] nodeTypes = Node.Type.values();
         for (Node.Type src : nodeTypes) {
             for (Node.Type dst : nodeTypes) {
                 EdgeType edge = new EdgeType(src, dst);
                 boolean isAllowed = edges.isAllowed(src, dst);
                 boolean isExpected = false;
                 for (EdgeType expected : expectedAllowed) {
                     if (expected.equals(edge)) {
                         isExpected = true;
                         break;
                     }
                 }
 
-                Assert.assertEquals("Edge type: " + src + " -> " + dst, isAllowed, isExpected);
+                Assertions.assertEquals(isAllowed, isExpected, "Edge type: " + src + " -> " + dst);
             }
         }
     }
 
     @Test
     public void dirToDirDirToCntEdges() {
         AllowedEdges edges = new AllowedEdges("dir:dir,dir:cnt");
         ArrayList<EdgeType> expected = new ArrayList<>();
         expected.add(new EdgeType(Node.Type.DIR, Node.Type.DIR));
         expected.add(new EdgeType(Node.Type.DIR, Node.Type.CNT));
         assertEdgeRestriction(edges, expected);
     }
 
     @Test
     public void relToRevRevToRevRevToDirEdges() {
         AllowedEdges edges = new AllowedEdges("rel:rev,rev:rev,rev:dir");
         ArrayList<EdgeType> expected = new ArrayList<>();
         expected.add(new EdgeType(Node.Type.REL, Node.Type.REV));
         expected.add(new EdgeType(Node.Type.REV, Node.Type.REV));
         expected.add(new EdgeType(Node.Type.REV, Node.Type.DIR));
         assertEdgeRestriction(edges, expected);
     }
 
     @Test
     public void revToAllDirToDirEdges() {
         AllowedEdges edges = new AllowedEdges("rev:*,dir:dir");
         ArrayList<EdgeType> expected = new ArrayList<>();
         for (Node.Type dst : Node.Type.values()) {
             expected.add(new EdgeType(Node.Type.REV, dst));
         }
         expected.add(new EdgeType(Node.Type.DIR, Node.Type.DIR));
         assertEdgeRestriction(edges, expected);
     }
 
     @Test
     public void allToCntEdges() {
         AllowedEdges edges = new AllowedEdges("*:cnt");
         ArrayList<EdgeType> expected = new ArrayList<>();
         for (Node.Type src : Node.Type.values()) {
             expected.add(new EdgeType(src, Node.Type.CNT));
         }
         assertEdgeRestriction(edges, expected);
     }
 
     @Test
     public void allEdges() {
         AllowedEdges edges = new AllowedEdges("*:*");
         ArrayList<EdgeType> expected = new ArrayList<>();
         for (Node.Type src : Node.Type.values()) {
             for (Node.Type dst : Node.Type.values()) {
                 expected.add(new EdgeType(src, dst));
             }
         }
         assertEdgeRestriction(edges, expected);
 
         // Special null value used to quickly bypass edge check when no restriction
         AllowedEdges edges2 = new AllowedEdges("*");
-        Assert.assertNull(edges2.restrictedTo);
+        Assertions.assertNull(edges2.restrictedTo);
     }
 
     @Test
     public void noEdges() {
         AllowedEdges edges = new AllowedEdges("");
         AllowedEdges edges2 = new AllowedEdges(null);
         ArrayList<EdgeType> expected = new ArrayList<>();
         assertEdgeRestriction(edges, expected);
         assertEdgeRestriction(edges2, expected);
     }
 }
diff --git a/java/src/test/java/org/softwareheritage/graph/GraphTest.java b/java/src/test/java/org/softwareheritage/graph/GraphTest.java
index 43f207d..df1afb7 100644
--- a/java/src/test/java/org/softwareheritage/graph/GraphTest.java
+++ b/java/src/test/java/org/softwareheritage/graph/GraphTest.java
@@ -1,30 +1,44 @@
 package org.softwareheritage.graph;
 
 import java.io.IOException;
 import java.nio.file.Path;
 import java.nio.file.Paths;
+import java.util.ArrayList;
 import java.util.Collection;
+import java.util.Iterator;
 
-import org.junit.Assert;
-import org.junit.BeforeClass;
-import static org.hamcrest.collection.IsIterableContainingInAnyOrder.containsInAnyOrder;
+import it.unimi.dsi.big.webgraph.LazyLongIterator;
+import it.unimi.dsi.big.webgraph.LazyLongIterators;
+import org.hamcrest.MatcherAssert;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeAll;
 
-import org.softwareheritage.graph.Graph;
+import static org.hamcrest.collection.IsIterableContainingInAnyOrder.containsInAnyOrder;
 
 public class GraphTest {
     static Graph graph;
 
     public static <T> void assertEqualsAnyOrder(Collection<T> expecteds, Collection<T> actuals) {
-        Assert.assertThat(expecteds, containsInAnyOrder(actuals.toArray()));
+        MatcherAssert.assertThat(expecteds, containsInAnyOrder(actuals.toArray()));
+    }
+
+    public static void assertLazyLongIteratorsEqual(LazyLongIterator expected, LazyLongIterator actual) {
+        ArrayList<Long> expectedList = new ArrayList<>();
+        ArrayList<Long> actualList = new ArrayList<>();
+        Iterator<Long> expectedIt = LazyLongIterators.eager(expected);
+        Iterator<Long> actualIt = LazyLongIterators.eager(actual);
+        expectedIt.forEachRemaining(expectedList::add);
+        actualIt.forEachRemaining(actualList::add);
+        Assertions.assertArrayEquals(expectedList.toArray(), actualList.toArray());
     }
 
-    @BeforeClass
+    @BeforeAll
     public static void setUp() throws IOException {
         Path graphPath = Paths.get("..", "swh", "graph", "tests", "dataset", "output", "example");
         graph = new Graph(graphPath.toString());
     }
 
     public Graph getGraph() {
         return graph;
     }
 }
diff --git a/java/src/test/java/org/softwareheritage/graph/LeavesTest.java b/java/src/test/java/org/softwareheritage/graph/LeavesTest.java
index a24cb61..a288d03 100644
--- a/java/src/test/java/org/softwareheritage/graph/LeavesTest.java
+++ b/java/src/test/java/org/softwareheritage/graph/LeavesTest.java
@@ -1,108 +1,107 @@
 package org.softwareheritage.graph;
 
 import java.util.ArrayList;
 
-import org.junit.Test;
-
+import org.junit.jupiter.api.Test;
 import org.softwareheritage.graph.server.Endpoint;
 
 // Avoid warnings concerning Endpoint.Output.result manual cast
 @SuppressWarnings("unchecked")
 public class LeavesTest extends GraphTest {
     @Test
     public void forwardFromSnp() {
         Graph graph = getGraph();
         SWHID src = new SWHID("swh:1:snp:0000000000000000000000000000000000000020");
         Endpoint endpoint = new Endpoint(graph, "forward", "*");
 
         ArrayList<SWHID> expectedLeaves = new ArrayList<>();
         expectedLeaves.add(new SWHID("swh:1:cnt:0000000000000000000000000000000000000001"));
         expectedLeaves.add(new SWHID("swh:1:cnt:0000000000000000000000000000000000000004"));
         expectedLeaves.add(new SWHID("swh:1:cnt:0000000000000000000000000000000000000005"));
         expectedLeaves.add(new SWHID("swh:1:cnt:0000000000000000000000000000000000000007"));
 
         ArrayList<SWHID> actualLeaves = (ArrayList) endpoint.leaves(new Endpoint.Input(src)).result;
         GraphTest.assertEqualsAnyOrder(expectedLeaves, actualLeaves);
     }
 
     @Test
     public void forwardFromRel() {
         Graph graph = getGraph();
         SWHID src = new SWHID("swh:1:rel:0000000000000000000000000000000000000019");
         Endpoint endpoint = new Endpoint(graph, "forward", "*");
 
         ArrayList<SWHID> expectedLeaves = new ArrayList<>();
         expectedLeaves.add(new SWHID("swh:1:cnt:0000000000000000000000000000000000000015"));
         expectedLeaves.add(new SWHID("swh:1:cnt:0000000000000000000000000000000000000014"));
         expectedLeaves.add(new SWHID("swh:1:cnt:0000000000000000000000000000000000000001"));
         expectedLeaves.add(new SWHID("swh:1:cnt:0000000000000000000000000000000000000004"));
         expectedLeaves.add(new SWHID("swh:1:cnt:0000000000000000000000000000000000000005"));
         expectedLeaves.add(new SWHID("swh:1:cnt:0000000000000000000000000000000000000007"));
         expectedLeaves.add(new SWHID("swh:1:cnt:0000000000000000000000000000000000000011"));
 
         ArrayList<SWHID> actualLeaves = (ArrayList) endpoint.leaves(new Endpoint.Input(src)).result;
         GraphTest.assertEqualsAnyOrder(expectedLeaves, actualLeaves);
     }
 
     @Test
     public void backwardFromLeaf() {
         Graph graph = getGraph();
 
         Endpoint endpoint1 = new Endpoint(graph, "backward", "*");
         SWHID src1 = new SWHID("swh:1:cnt:0000000000000000000000000000000000000015");
         ArrayList<SWHID> expectedLeaves1 = new ArrayList<>();
         expectedLeaves1.add(new SWHID("swh:1:rel:0000000000000000000000000000000000000019"));
         ArrayList<SWHID> actualLeaves1 = (ArrayList) endpoint1.leaves(new Endpoint.Input(src1)).result;
         GraphTest.assertEqualsAnyOrder(expectedLeaves1, actualLeaves1);
 
         Endpoint endpoint2 = new Endpoint(graph, "backward", "*");
         SWHID src2 = new SWHID("swh:1:cnt:0000000000000000000000000000000000000004");
         ArrayList<SWHID> expectedLeaves2 = new ArrayList<>();
         expectedLeaves2.add(new SWHID("swh:1:ori:0000000000000000000000000000000000000021"));
         expectedLeaves2.add(new SWHID("swh:1:rel:0000000000000000000000000000000000000019"));
         ArrayList<SWHID> actualLeaves2 = (ArrayList) endpoint2.leaves(new Endpoint.Input(src2)).result;
         GraphTest.assertEqualsAnyOrder(expectedLeaves2, actualLeaves2);
     }
 
     @Test
     public void forwardRevToRevOnly() {
         Graph graph = getGraph();
         SWHID src = new SWHID("swh:1:rev:0000000000000000000000000000000000000018");
         Endpoint endpoint = new Endpoint(graph, "forward", "rev:rev");
 
         ArrayList<SWHID> expectedLeaves = new ArrayList<>();
         expectedLeaves.add(new SWHID("swh:1:rev:0000000000000000000000000000000000000003"));
 
         ArrayList<SWHID> actualLeaves = (ArrayList) endpoint.leaves(new Endpoint.Input(src)).result;
         GraphTest.assertEqualsAnyOrder(expectedLeaves, actualLeaves);
     }
 
     @Test
     public void forwardDirToAll() {
         Graph graph = getGraph();
         SWHID src = new SWHID("swh:1:dir:0000000000000000000000000000000000000008");
         Endpoint endpoint = new Endpoint(graph, "forward", "dir:*");
 
         ArrayList<SWHID> expectedLeaves = new ArrayList<>();
         expectedLeaves.add(new SWHID("swh:1:cnt:0000000000000000000000000000000000000004"));
         expectedLeaves.add(new SWHID("swh:1:cnt:0000000000000000000000000000000000000005"));
         expectedLeaves.add(new SWHID("swh:1:cnt:0000000000000000000000000000000000000001"));
         expectedLeaves.add(new SWHID("swh:1:cnt:0000000000000000000000000000000000000007"));
 
         ArrayList<SWHID> actualLeaves = (ArrayList) endpoint.leaves(new Endpoint.Input(src)).result;
         GraphTest.assertEqualsAnyOrder(expectedLeaves, actualLeaves);
     }
 
     @Test
     public void backwardCntToDirDirToDir() {
         Graph graph = getGraph();
         SWHID src = new SWHID("swh:1:cnt:0000000000000000000000000000000000000005");
         Endpoint endpoint = new Endpoint(graph, "backward", "cnt:dir,dir:dir");
 
         ArrayList<SWHID> expectedLeaves = new ArrayList<>();
         expectedLeaves.add(new SWHID("swh:1:dir:0000000000000000000000000000000000000012"));
 
         ArrayList<SWHID> actualLeaves = (ArrayList) endpoint.leaves(new Endpoint.Input(src)).result;
         GraphTest.assertEqualsAnyOrder(expectedLeaves, actualLeaves);
     }
 }
diff --git a/java/src/test/java/org/softwareheritage/graph/NeighborsTest.java b/java/src/test/java/org/softwareheritage/graph/NeighborsTest.java
index b20bcb6..cf41aa4 100644
--- a/java/src/test/java/org/softwareheritage/graph/NeighborsTest.java
+++ b/java/src/test/java/org/softwareheritage/graph/NeighborsTest.java
@@ -1,142 +1,141 @@
 package org.softwareheritage.graph;
 
 import java.util.ArrayList;
 
-import org.junit.Test;
-
+import org.junit.jupiter.api.Test;
 import org.softwareheritage.graph.server.Endpoint;
 
 // Avoid warnings concerning Endpoint.Output.result manual cast
 @SuppressWarnings("unchecked")
 public class NeighborsTest extends GraphTest {
     @Test
     public void zeroNeighbor() {
         Graph graph = getGraph();
         ArrayList<SWHID> expectedNodes = new ArrayList<>();
 
         SWHID src1 = new SWHID("swh:1:ori:0000000000000000000000000000000000000021");
         Endpoint endpoint1 = new Endpoint(graph, "backward", "*");
         ArrayList<SWHID> actuals1 = (ArrayList) endpoint1.neighbors(new Endpoint.Input(src1)).result;
         GraphTest.assertEqualsAnyOrder(expectedNodes, actuals1);
 
         SWHID src2 = new SWHID("swh:1:cnt:0000000000000000000000000000000000000004");
         Endpoint endpoint2 = new Endpoint(graph, "forward", "*");
         ArrayList<SWHID> actuals2 = (ArrayList) endpoint2.neighbors(new Endpoint.Input(src2)).result;
         GraphTest.assertEqualsAnyOrder(expectedNodes, actuals2);
 
         SWHID src3 = new SWHID("swh:1:cnt:0000000000000000000000000000000000000015");
         Endpoint endpoint3 = new Endpoint(graph, "forward", "*");
         ArrayList<SWHID> actuals3 = (ArrayList) endpoint3.neighbors(new Endpoint.Input(src3)).result;
         GraphTest.assertEqualsAnyOrder(expectedNodes, actuals3);
 
         SWHID src4 = new SWHID("swh:1:rel:0000000000000000000000000000000000000019");
         Endpoint endpoint4 = new Endpoint(graph, "backward", "*");
         ArrayList<SWHID> actuals4 = (ArrayList) endpoint4.neighbors(new Endpoint.Input(src4)).result;
         GraphTest.assertEqualsAnyOrder(expectedNodes, actuals4);
 
         SWHID src5 = new SWHID("swh:1:dir:0000000000000000000000000000000000000008");
         Endpoint endpoint5 = new Endpoint(graph, "forward", "snp:*,rev:*,rel:*");
         ArrayList<SWHID> actuals5 = (ArrayList) endpoint5.neighbors(new Endpoint.Input(src5)).result;
         GraphTest.assertEqualsAnyOrder(expectedNodes, actuals5);
     }
 
     @Test
     public void oneNeighbor() {
         Graph graph = getGraph();
 
         SWHID src1 = new SWHID("swh:1:rev:0000000000000000000000000000000000000003");
         Endpoint endpoint1 = new Endpoint(graph, "forward", "*");
         ArrayList<SWHID> expectedNodes1 = new ArrayList<>();
         expectedNodes1.add(new SWHID("swh:1:dir:0000000000000000000000000000000000000002"));
         ArrayList<SWHID> actuals1 = (ArrayList) endpoint1.neighbors(new Endpoint.Input(src1)).result;
         GraphTest.assertEqualsAnyOrder(expectedNodes1, actuals1);
 
         SWHID src2 = new SWHID("swh:1:dir:0000000000000000000000000000000000000017");
         Endpoint endpoint2 = new Endpoint(graph, "forward", "dir:cnt");
         ArrayList<SWHID> expectedNodes2 = new ArrayList<>();
         expectedNodes2.add(new SWHID("swh:1:cnt:0000000000000000000000000000000000000014"));
         ArrayList<SWHID> actuals2 = (ArrayList) endpoint2.neighbors(new Endpoint.Input(src2)).result;
         GraphTest.assertEqualsAnyOrder(expectedNodes2, actuals2);
 
         SWHID src3 = new SWHID("swh:1:dir:0000000000000000000000000000000000000012");
         Endpoint endpoint3 = new Endpoint(graph, "backward", "*");
         ArrayList<SWHID> expectedNodes3 = new ArrayList<>();
         expectedNodes3.add(new SWHID("swh:1:rev:0000000000000000000000000000000000000013"));
         ArrayList<SWHID> actuals3 = (ArrayList) endpoint3.neighbors(new Endpoint.Input(src3)).result;
         GraphTest.assertEqualsAnyOrder(expectedNodes3, actuals3);
 
         SWHID src4 = new SWHID("swh:1:rev:0000000000000000000000000000000000000009");
         Endpoint endpoint4 = new Endpoint(graph, "backward", "rev:rev");
         ArrayList<SWHID> expectedNodes4 = new ArrayList<>();
         expectedNodes4.add(new SWHID("swh:1:rev:0000000000000000000000000000000000000013"));
         ArrayList<SWHID> actuals4 = (ArrayList) endpoint4.neighbors(new Endpoint.Input(src4)).result;
         GraphTest.assertEqualsAnyOrder(expectedNodes4, actuals4);
 
         SWHID src5 = new SWHID("swh:1:snp:0000000000000000000000000000000000000020");
         Endpoint endpoint5 = new Endpoint(graph, "backward", "*");
         ArrayList<SWHID> expectedNodes5 = new ArrayList<>();
         expectedNodes5.add(new SWHID("swh:1:ori:0000000000000000000000000000000000000021"));
         ArrayList<SWHID> actuals5 = (ArrayList) endpoint5.neighbors(new Endpoint.Input(src5)).result;
         GraphTest.assertEqualsAnyOrder(expectedNodes5, actuals5);
     }
 
     @Test
     public void twoNeighbors() {
         Graph graph = getGraph();
 
         SWHID src1 = new SWHID("swh:1:snp:0000000000000000000000000000000000000020");
         Endpoint endpoint1 = new Endpoint(graph, "forward", "*");
         ArrayList<SWHID> expectedNodes1 = new ArrayList<>();
         expectedNodes1.add(new SWHID("swh:1:rel:0000000000000000000000000000000000000010"));
         expectedNodes1.add(new SWHID("swh:1:rev:0000000000000000000000000000000000000009"));
         ArrayList<SWHID> actuals1 = (ArrayList) endpoint1.neighbors(new Endpoint.Input(src1)).result;
         GraphTest.assertEqualsAnyOrder(expectedNodes1, actuals1);
 
         SWHID src2 = new SWHID("swh:1:dir:0000000000000000000000000000000000000008");
         Endpoint endpoint2 = new Endpoint(graph, "forward", "dir:cnt");
         ArrayList<SWHID> expectedNodes2 = new ArrayList<>();
         expectedNodes2.add(new SWHID("swh:1:cnt:0000000000000000000000000000000000000001"));
         expectedNodes2.add(new SWHID("swh:1:cnt:0000000000000000000000000000000000000007"));
         ArrayList<SWHID> actuals2 = (ArrayList) endpoint2.neighbors(new Endpoint.Input(src2)).result;
         GraphTest.assertEqualsAnyOrder(expectedNodes2, actuals2);
 
         SWHID src3 = new SWHID("swh:1:cnt:0000000000000000000000000000000000000001");
         Endpoint endpoint3 = new Endpoint(graph, "backward", "*");
         ArrayList<SWHID> expectedNodes3 = new ArrayList<>();
         expectedNodes3.add(new SWHID("swh:1:dir:0000000000000000000000000000000000000008"));
         expectedNodes3.add(new SWHID("swh:1:dir:0000000000000000000000000000000000000002"));
         ArrayList<SWHID> actuals3 = (ArrayList) endpoint3.neighbors(new Endpoint.Input(src3)).result;
         GraphTest.assertEqualsAnyOrder(expectedNodes3, actuals3);
 
         SWHID src4 = new SWHID("swh:1:rev:0000000000000000000000000000000000000009");
         Endpoint endpoint4 = new Endpoint(graph, "backward", "rev:snp,rev:rel");
         ArrayList<SWHID> expectedNodes4 = new ArrayList<>();
         expectedNodes4.add(new SWHID("swh:1:snp:0000000000000000000000000000000000000020"));
         expectedNodes4.add(new SWHID("swh:1:rel:0000000000000000000000000000000000000010"));
         ArrayList<SWHID> actuals4 = (ArrayList) endpoint4.neighbors(new Endpoint.Input(src4)).result;
         GraphTest.assertEqualsAnyOrder(expectedNodes4, actuals4);
     }
 
     @Test
     public void threeNeighbors() {
         Graph graph = getGraph();
 
         SWHID src1 = new SWHID("swh:1:dir:0000000000000000000000000000000000000008");
         Endpoint endpoint1 = new Endpoint(graph, "forward", "*");
         ArrayList<SWHID> expectedNodes1 = new ArrayList<>();
         expectedNodes1.add(new SWHID("swh:1:dir:0000000000000000000000000000000000000006"));
         expectedNodes1.add(new SWHID("swh:1:cnt:0000000000000000000000000000000000000001"));
         expectedNodes1.add(new SWHID("swh:1:cnt:0000000000000000000000000000000000000007"));
         ArrayList<SWHID> actuals1 = (ArrayList) endpoint1.neighbors(new Endpoint.Input(src1)).result;
         GraphTest.assertEqualsAnyOrder(expectedNodes1, actuals1);
 
         SWHID src2 = new SWHID("swh:1:rev:0000000000000000000000000000000000000009");
         Endpoint endpoint2 = new Endpoint(graph, "backward", "*");
         ArrayList<SWHID> expectedNodes2 = new ArrayList<>();
         expectedNodes2.add(new SWHID("swh:1:snp:0000000000000000000000000000000000000020"));
         expectedNodes2.add(new SWHID("swh:1:rel:0000000000000000000000000000000000000010"));
         expectedNodes2.add(new SWHID("swh:1:rev:0000000000000000000000000000000000000013"));
         ArrayList<SWHID> actuals2 = (ArrayList) endpoint2.neighbors(new Endpoint.Input(src2)).result;
         GraphTest.assertEqualsAnyOrder(expectedNodes2, actuals2);
     }
 }
diff --git a/java/src/test/java/org/softwareheritage/graph/VisitTest.java b/java/src/test/java/org/softwareheritage/graph/VisitTest.java
index 11fc97c..9cce68d 100644
--- a/java/src/test/java/org/softwareheritage/graph/VisitTest.java
+++ b/java/src/test/java/org/softwareheritage/graph/VisitTest.java
@@ -1,543 +1,540 @@
 package org.softwareheritage.graph;
 
 import java.util.ArrayList;
 import java.util.Set;
 import java.util.HashSet;
 
-import org.junit.Test;
-
+import org.junit.jupiter.api.Test;
 import org.softwareheritage.graph.server.Endpoint;
 
 // Avoid warnings concerning Endpoint.Output.result manual cast
 @SuppressWarnings("unchecked")
 public class VisitTest extends GraphTest {
     private void assertSameNodesFromPaths(ArrayList<SwhPath> paths, ArrayList<SWHID> nodes) {
         Set<SWHID> expectedNodes = new HashSet<SWHID>();
         for (SwhPath path : paths) {
-            for (SWHID node : path.getPath()) {
-                expectedNodes.add(node);
-            }
+            expectedNodes.addAll(path.getPath());
         }
         GraphTest.assertEqualsAnyOrder(expectedNodes, nodes);
     }
 
     @Test
     public void forwardFromRoot() {
         Graph graph = getGraph();
         SWHID swhid = new SWHID("swh:1:ori:0000000000000000000000000000000000000021");
         Endpoint endpoint1 = new Endpoint(graph, "forward", "*");
         ArrayList<SwhPath> paths = (ArrayList) endpoint1.visitPaths(new Endpoint.Input(swhid)).result;
         Endpoint endpoint2 = new Endpoint(graph, "forward", "*");
         ArrayList<SWHID> nodes = (ArrayList) endpoint2.visitNodes(new Endpoint.Input(swhid)).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();
         SWHID swhid = new SWHID("swh:1:dir:0000000000000000000000000000000000000012");
         Endpoint endpoint1 = new Endpoint(graph, "forward", "*");
         ArrayList<SwhPath> paths = (ArrayList) endpoint1.visitPaths(new Endpoint.Input(swhid)).result;
         Endpoint endpoint2 = new Endpoint(graph, "forward", "*");
         ArrayList<SWHID> nodes = (ArrayList) endpoint2.visitNodes(new Endpoint.Input(swhid)).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();
         SWHID swhid = new SWHID("swh:1:cnt:0000000000000000000000000000000000000004");
         Endpoint endpoint1 = new Endpoint(graph, "forward", "*");
         ArrayList<SwhPath> paths = (ArrayList) endpoint1.visitPaths(new Endpoint.Input(swhid)).result;
         Endpoint endpoint2 = new Endpoint(graph, "forward", "*");
         ArrayList<SWHID> nodes = (ArrayList) endpoint2.visitNodes(new Endpoint.Input(swhid)).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();
         SWHID swhid = new SWHID("swh:1:ori:0000000000000000000000000000000000000021");
         Endpoint endpoint1 = new Endpoint(graph, "backward", "*");
         ArrayList<SwhPath> paths = (ArrayList) endpoint1.visitPaths(new Endpoint.Input(swhid)).result;
         Endpoint endpoint2 = new Endpoint(graph, "backward", "*");
         ArrayList<SWHID> nodes = (ArrayList) endpoint2.visitNodes(new Endpoint.Input(swhid)).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();
         SWHID swhid = new SWHID("swh:1:dir:0000000000000000000000000000000000000012");
         Endpoint endpoint1 = new Endpoint(graph, "backward", "*");
         ArrayList<SwhPath> paths = (ArrayList) endpoint1.visitPaths(new Endpoint.Input(swhid)).result;
         Endpoint endpoint2 = new Endpoint(graph, "backward", "*");
         ArrayList<SWHID> nodes = (ArrayList) endpoint2.visitNodes(new Endpoint.Input(swhid)).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();
         SWHID swhid = new SWHID("swh:1:cnt:0000000000000000000000000000000000000004");
         Endpoint endpoint1 = new Endpoint(graph, "backward", "*");
         ArrayList<SwhPath> paths = (ArrayList) endpoint1.visitPaths(new Endpoint.Input(swhid)).result;
         Endpoint endpoint2 = new Endpoint(graph, "backward", "*");
         ArrayList<SWHID> nodes = (ArrayList) endpoint2.visitNodes(new Endpoint.Input(swhid)).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();
         SWHID swhid = new SWHID("swh:1:snp:0000000000000000000000000000000000000020");
         Endpoint endpoint1 = new Endpoint(graph, "forward", "snp:rev");
         ArrayList<SwhPath> paths = (ArrayList) endpoint1.visitPaths(new Endpoint.Input(swhid)).result;
         Endpoint endpoint2 = new Endpoint(graph, "forward", "snp:rev");
         ArrayList<SWHID> nodes = (ArrayList) endpoint2.visitNodes(new Endpoint.Input(swhid)).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();
         SWHID swhid = new SWHID("swh:1:rel:0000000000000000000000000000000000000010");
         Endpoint endpoint1 = new Endpoint(graph, "forward", "rel:rev,rev:rev");
         ArrayList<SwhPath> paths = (ArrayList) endpoint1.visitPaths(new Endpoint.Input(swhid)).result;
         Endpoint endpoint2 = new Endpoint(graph, "forward", "rel:rev,rev:rev");
         ArrayList<SWHID> nodes = (ArrayList) endpoint2.visitNodes(new Endpoint.Input(swhid)).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();
         SWHID swhid = new SWHID("swh:1:rev:0000000000000000000000000000000000000013");
         Endpoint endpoint1 = new Endpoint(graph, "forward", "rev:*,dir:*");
         ArrayList<SwhPath> paths = (ArrayList) endpoint1.visitPaths(new Endpoint.Input(swhid)).result;
         Endpoint endpoint2 = new Endpoint(graph, "forward", "rev:*,dir:*");
         ArrayList<SWHID> nodes = (ArrayList) endpoint2.visitNodes(new Endpoint.Input(swhid)).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();
         SWHID swhid = new SWHID("swh:1:snp:0000000000000000000000000000000000000020");
         Endpoint endpoint1 = new Endpoint(graph, "forward", "snp:*,rev:*");
         ArrayList<SwhPath> paths = (ArrayList) endpoint1.visitPaths(new Endpoint.Input(swhid)).result;
         Endpoint endpoint2 = new Endpoint(graph, "forward", "snp:*,rev:*");
         ArrayList<SWHID> nodes = (ArrayList) endpoint2.visitNodes(new Endpoint.Input(swhid)).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();
         SWHID swhid = new SWHID("swh:1:snp:0000000000000000000000000000000000000020");
         Endpoint endpoint1 = new Endpoint(graph, "forward", "");
         ArrayList<SwhPath> paths = (ArrayList) endpoint1.visitPaths(new Endpoint.Input(swhid)).result;
         Endpoint endpoint2 = new Endpoint(graph, "forward", "");
         ArrayList<SWHID> nodes = (ArrayList) endpoint2.visitNodes(new Endpoint.Input(swhid)).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();
         SWHID swhid = new SWHID("swh:1:rev:0000000000000000000000000000000000000003");
         Endpoint endpoint1 = new Endpoint(graph, "backward", "rev:rev,rev:rel");
         ArrayList<SwhPath> paths = (ArrayList) endpoint1.visitPaths(new Endpoint.Input(swhid)).result;
         Endpoint endpoint2 = new Endpoint(graph, "backward", "rev:rev,rev:rel");
         ArrayList<SWHID> nodes = (ArrayList) endpoint2.visitNodes(new Endpoint.Input(swhid)).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();
         SWHID swhid = new SWHID("swh:1:ori:0000000000000000000000000000000000000021");
         Endpoint endpoint = new Endpoint(graph, "forward", "*");
         ArrayList<SWHID> nodes = (ArrayList) endpoint.visitNodes(new Endpoint.Input(swhid)).result;
 
         ArrayList<SWHID> expectedNodes = new ArrayList<SWHID>();
         expectedNodes.add(new SWHID("swh:1:ori:0000000000000000000000000000000000000021"));
         expectedNodes.add(new SWHID("swh:1:snp:0000000000000000000000000000000000000020"));
         expectedNodes.add(new SWHID("swh:1:rel:0000000000000000000000000000000000000010"));
         expectedNodes.add(new SWHID("swh:1:rev:0000000000000000000000000000000000000009"));
         expectedNodes.add(new SWHID("swh:1:rev:0000000000000000000000000000000000000003"));
         expectedNodes.add(new SWHID("swh:1:dir:0000000000000000000000000000000000000002"));
         expectedNodes.add(new SWHID("swh:1:cnt:0000000000000000000000000000000000000001"));
         expectedNodes.add(new SWHID("swh:1:dir:0000000000000000000000000000000000000008"));
         expectedNodes.add(new SWHID("swh:1:dir:0000000000000000000000000000000000000006"));
         expectedNodes.add(new SWHID("swh:1:cnt:0000000000000000000000000000000000000004"));
         expectedNodes.add(new SWHID("swh:1:cnt:0000000000000000000000000000000000000005"));
         expectedNodes.add(new SWHID("swh:1:cnt:0000000000000000000000000000000000000007"));
 
         GraphTest.assertEqualsAnyOrder(expectedNodes, nodes);
     }
 
     @Test
     public void backwardRevToAllNodesOnly() {
         Graph graph = getGraph();
         SWHID swhid = new SWHID("swh:1:rev:0000000000000000000000000000000000000003");
         Endpoint endpoint = new Endpoint(graph, "backward", "rev:*");
         ArrayList<SWHID> nodes = (ArrayList) endpoint.visitNodes(new Endpoint.Input(swhid)).result;
 
         ArrayList<SWHID> expectedNodes = new ArrayList<SWHID>();
         expectedNodes.add(new SWHID("swh:1:rev:0000000000000000000000000000000000000003"));
         expectedNodes.add(new SWHID("swh:1:rev:0000000000000000000000000000000000000009"));
         expectedNodes.add(new SWHID("swh:1:snp:0000000000000000000000000000000000000020"));
         expectedNodes.add(new SWHID("swh:1:rel:0000000000000000000000000000000000000010"));
         expectedNodes.add(new SWHID("swh:1:rev:0000000000000000000000000000000000000013"));
         expectedNodes.add(new SWHID("swh:1:rev:0000000000000000000000000000000000000018"));
         expectedNodes.add(new SWHID("swh:1:rel:0000000000000000000000000000000000000019"));
 
         GraphTest.assertEqualsAnyOrder(expectedNodes, nodes);
     }
 }
diff --git a/java/src/test/java/org/softwareheritage/graph/WalkTest.java b/java/src/test/java/org/softwareheritage/graph/WalkTest.java
index f575a66..fe463d2 100644
--- a/java/src/test/java/org/softwareheritage/graph/WalkTest.java
+++ b/java/src/test/java/org/softwareheritage/graph/WalkTest.java
@@ -1,234 +1,233 @@
 package org.softwareheritage.graph;
 
 import java.util.Arrays;
 import java.util.List;
 
-import org.junit.Assert;
-import org.junit.Test;
-
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
 import org.softwareheritage.graph.server.Endpoint;
 
 public class WalkTest extends GraphTest {
     @Test
     public void forwardRootToLeaf() {
         Graph graph = getGraph();
         SWHID src = new SWHID("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"
         );
 
         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));
+        Assertions.assertTrue(possibleSolutions.contains(dfsPath));
+        Assertions.assertTrue(possibleSolutions.contains(bfsPath));
     }
 
     @Test
     public void forwardLeafToLeaf() {
         Graph graph = getGraph();
         SWHID src = new SWHID("swh:1:cnt:0000000000000000000000000000000000000007");
         String dstFmt = "cnt";
 
         SwhPath expectedPath =
             new SwhPath(
             "swh:1:cnt:0000000000000000000000000000000000000007"
         );
 
         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);
+        Assertions.assertEquals(dfsPath, expectedPath);
+        Assertions.assertEquals(bfsPath, expectedPath);
     }
 
     @Test
     public void forwardRevToRev() {
         Graph graph = getGraph();
         SWHID src = new SWHID("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"
         );
 
         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);
+        Assertions.assertEquals(dfsPath, expectedPath);
+        Assertions.assertEquals(bfsPath, expectedPath);
     }
 
     @Test
     public void backwardRevToRev() {
         Graph graph = getGraph();
         SWHID src = new SWHID("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"
         );
 
         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);
+        Assertions.assertEquals(dfsPath, expectedPath);
+        Assertions.assertEquals(bfsPath, expectedPath);
     }
 
     @Test
     public void backwardCntToFirstSnp() {
         Graph graph = getGraph();
         SWHID src = new SWHID("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"
         );
 
         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));
+        Assertions.assertTrue(possibleSolutions.contains(dfsPath));
+        Assertions.assertTrue(possibleSolutions.contains(bfsPath));
     }
 
     @Test
     public void forwardRevToFirstCnt() {
         Graph graph = getGraph();
         SWHID src = new SWHID("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"
         );
 
         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));
+        Assertions.assertTrue(possibleSolutions.contains(dfsPath));
+        Assertions.assertTrue(possibleSolutions.contains(bfsPath));
     }
 
     @Test
     public void backwardDirToFirstRel() {
         Graph graph = getGraph();
         SWHID src = new SWHID("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"
         );
 
         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);
+        Assertions.assertEquals(dfsPath, expectedPath);
+        Assertions.assertEquals(bfsPath, expectedPath);
     }
 }