diff --git a/api/server/src/test/java/org/softwareheritage/graph/GraphTest.java b/api/server/src/test/java/org/softwareheritage/graph/GraphTest.java
index 81a6aa3..8ba1d07 100644
--- a/api/server/src/test/java/org/softwareheritage/graph/GraphTest.java
+++ b/api/server/src/test/java/org/softwareheritage/graph/GraphTest.java
@@ -1,23 +1,30 @@
 package org.softwareheritage.graph;
 
 import java.io.IOException;
 import java.nio.file.Path;
 import java.nio.file.Paths;
+import java.util.Collection;
 
+import org.junit.Assert;
 import org.junit.BeforeClass;
+import static org.hamcrest.collection.IsIterableContainingInAnyOrder.containsInAnyOrder;
 
 import org.softwareheritage.graph.Graph;
 
 public class GraphTest {
   static Graph graph;
 
+  public static <T> void assertEqualsAnyOrder(Collection<T> expecteds, Collection<T> actuals) {
+    Assert.assertThat(expecteds, containsInAnyOrder(actuals.toArray()));
+  }
+
   @BeforeClass
   public static void setUp() throws IOException {
     Path graphPath = Paths.get("src", "test", "dataset", "output", "example");
     graph = new Graph(graphPath.toString());
   }
 
   public Graph getGraph() {
     return graph;
   }
 }
diff --git a/api/server/src/test/java/org/softwareheritage/graph/LeavesTest.java b/api/server/src/test/java/org/softwareheritage/graph/LeavesTest.java
index 725a4a7..f85948b 100644
--- a/api/server/src/test/java/org/softwareheritage/graph/LeavesTest.java
+++ b/api/server/src/test/java/org/softwareheritage/graph/LeavesTest.java
@@ -1,103 +1,102 @@
 package org.softwareheritage.graph;
 
 import java.util.ArrayList;
 
 import org.junit.Test;
-import static org.junit.Assert.assertEquals;
 
 import org.softwareheritage.graph.Graph;
 import org.softwareheritage.graph.GraphTest;
 import org.softwareheritage.graph.SwhId;
 import org.softwareheritage.graph.algo.Leaves;
 
 public class LeavesTest extends GraphTest {
   @Test
   public void forwardFromSnp() {
     Graph graph = getGraph();
     SwhId src = new SwhId("swh:1:snp:0000000000000000000000000000000000000020");
     Leaves leaves = new Leaves(graph, src, "*", "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"));
 
-    assertEquals(expectedLeaves, leaves.getLeaves());
+    GraphTest.assertEqualsAnyOrder(expectedLeaves, leaves.getLeaves());
   }
 
   @Test
   public void forwardFromRel() {
     Graph graph = getGraph();
     SwhId src = new SwhId("swh:1:rel:0000000000000000000000000000000000000019");
     Leaves leaves = new Leaves(graph, src, "*", "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"));
 
-    assertEquals(expectedLeaves, leaves.getLeaves());
+    GraphTest.assertEqualsAnyOrder(expectedLeaves, leaves.getLeaves());
   }
 
   @Test
   public void backwardFromLeaf() {
     Graph graph = getGraph();
 
     SwhId src1 = new SwhId("swh:1:cnt:0000000000000000000000000000000000000015");
     Leaves leaves1 = new Leaves(graph, src1, "*", "backward");
     ArrayList<SwhId> expectedLeaves1 = new ArrayList<>();
     expectedLeaves1.add(new SwhId("swh:1:rel:0000000000000000000000000000000000000019"));
-    assertEquals(expectedLeaves1, leaves1.getLeaves());
+    GraphTest.assertEqualsAnyOrder(expectedLeaves1, leaves1.getLeaves());
 
     SwhId src2 = new SwhId("swh:1:cnt:0000000000000000000000000000000000000004");
     Leaves leaves2 = new Leaves(graph, src2, "*", "backward");
     ArrayList<SwhId> expectedLeaves2 = new ArrayList<>();
     expectedLeaves2.add(new SwhId("swh:1:snp:0000000000000000000000000000000000000020"));
     expectedLeaves2.add(new SwhId("swh:1:rel:0000000000000000000000000000000000000019"));
-    assertEquals(expectedLeaves2, leaves2.getLeaves());
+    GraphTest.assertEqualsAnyOrder(expectedLeaves2, leaves2.getLeaves());
   }
 
   @Test
   public void forwardRevToRevOnly() {
     Graph graph = getGraph();
     SwhId src = new SwhId("swh:1:rev:0000000000000000000000000000000000000018");
     Leaves leaves = new Leaves(graph, src, "rev:rev", "forward");
 
     ArrayList<SwhId> expectedLeaves = new ArrayList<>();
     expectedLeaves.add(new SwhId("swh:1:rev:0000000000000000000000000000000000000003"));
 
-    assertEquals(expectedLeaves, leaves.getLeaves());
+    GraphTest.assertEqualsAnyOrder(expectedLeaves, leaves.getLeaves());
   }
 
   @Test
   public void forwardDirToAll() {
     Graph graph = getGraph();
     SwhId src = new SwhId("swh:1:dir:0000000000000000000000000000000000000008");
     Leaves leaves = new Leaves(graph, src, "dir:*", "forward");
 
     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"));
 
-    assertEquals(expectedLeaves, leaves.getLeaves());
+    GraphTest.assertEqualsAnyOrder(expectedLeaves, leaves.getLeaves());
   }
 
   @Test
   public void backwardCntToDirDirToDir() {
     Graph graph = getGraph();
     SwhId src = new SwhId("swh:1:cnt:0000000000000000000000000000000000000005");
     Leaves leaves = new Leaves(graph, src, "cnt:dir,dir:dir", "backward");
 
     ArrayList<SwhId> expectedLeaves = new ArrayList<>();
     expectedLeaves.add(new SwhId("swh:1:dir:0000000000000000000000000000000000000012"));
 
-    assertEquals(expectedLeaves, leaves.getLeaves());
+    GraphTest.assertEqualsAnyOrder(expectedLeaves, leaves.getLeaves());
   }
 }
diff --git a/api/server/src/test/java/org/softwareheritage/graph/NeighborsTest.java b/api/server/src/test/java/org/softwareheritage/graph/NeighborsTest.java
index 800301f..c70e225 100644
--- a/api/server/src/test/java/org/softwareheritage/graph/NeighborsTest.java
+++ b/api/server/src/test/java/org/softwareheritage/graph/NeighborsTest.java
@@ -1,122 +1,121 @@
 package org.softwareheritage.graph;
 
 import java.util.ArrayList;
 
 import org.junit.Test;
-import static org.junit.Assert.assertEquals;
 
 import org.softwareheritage.graph.Graph;
 import org.softwareheritage.graph.GraphTest;
 import org.softwareheritage.graph.SwhId;
 import org.softwareheritage.graph.algo.Neighbors;
 
 public class NeighborsTest extends GraphTest {
   @Test
   public void zeroNeighbor() {
     Graph graph = getGraph();
     ArrayList<SwhId> expectedNodes = new ArrayList<>();
 
     SwhId src1 = new SwhId("swh:1:snp:0000000000000000000000000000000000000020");
     Neighbors neighbors1 = new Neighbors(graph, src1, "*", "backward");
-    assertEquals(expectedNodes, neighbors1.getNeighbors());
+    GraphTest.assertEqualsAnyOrder(expectedNodes, neighbors1.getNeighbors());
 
     SwhId src2 = new SwhId("swh:1:cnt:0000000000000000000000000000000000000004");
     Neighbors neighbors2 = new Neighbors(graph, src2, "*", "forward");
-    assertEquals(expectedNodes, neighbors2.getNeighbors());
+    GraphTest.assertEqualsAnyOrder(expectedNodes, neighbors2.getNeighbors());
 
     SwhId src3 = new SwhId("swh:1:cnt:0000000000000000000000000000000000000015");
     Neighbors neighbors3 = new Neighbors(graph, src3, "*", "forward");
-    assertEquals(expectedNodes, neighbors3.getNeighbors());
+    GraphTest.assertEqualsAnyOrder(expectedNodes, neighbors3.getNeighbors());
 
     SwhId src4 = new SwhId("swh:1:rel:0000000000000000000000000000000000000019");
     Neighbors neighbors4 = new Neighbors(graph, src4, "*", "backward");
-    assertEquals(expectedNodes, neighbors4.getNeighbors());
+    GraphTest.assertEqualsAnyOrder(expectedNodes, neighbors4.getNeighbors());
 
     SwhId src5 = new SwhId("swh:1:dir:0000000000000000000000000000000000000008");
     Neighbors neighbors5 = new Neighbors(graph, src5, "snp:*,rev:*,rel:*", "forward");
-    assertEquals(expectedNodes, neighbors5.getNeighbors());
+    GraphTest.assertEqualsAnyOrder(expectedNodes, neighbors5.getNeighbors());
   }
 
   @Test
   public void oneNeighbor() {
     Graph graph = getGraph();
 
     SwhId src1 = new SwhId("swh:1:rev:0000000000000000000000000000000000000003");
     Neighbors neighbors1 = new Neighbors(graph, src1, "*", "forward");
     ArrayList<SwhId> expectedNodes1 = new ArrayList<>();
     expectedNodes1.add(new SwhId("swh:1:dir:0000000000000000000000000000000000000002"));
-    assertEquals(expectedNodes1, neighbors1.getNeighbors());
+    GraphTest.assertEqualsAnyOrder(expectedNodes1, neighbors1.getNeighbors());
 
     SwhId src2 = new SwhId("swh:1:dir:0000000000000000000000000000000000000017");
     Neighbors neighbors2 = new Neighbors(graph, src2, "dir:cnt", "forward");
     ArrayList<SwhId> expectedNodes2 = new ArrayList<>();
     expectedNodes2.add(new SwhId("swh:1:cnt:0000000000000000000000000000000000000014"));
-    assertEquals(expectedNodes2, neighbors2.getNeighbors());
+    GraphTest.assertEqualsAnyOrder(expectedNodes2, neighbors2.getNeighbors());
 
     SwhId src3 = new SwhId("swh:1:dir:0000000000000000000000000000000000000012");
     Neighbors neighbors3 = new Neighbors(graph, src3, "*", "backward");
     ArrayList<SwhId> expectedNodes3 = new ArrayList<>();
     expectedNodes3.add(new SwhId("swh:1:rev:0000000000000000000000000000000000000013"));
-    assertEquals(expectedNodes3, neighbors3.getNeighbors());
+    GraphTest.assertEqualsAnyOrder(expectedNodes3, neighbors3.getNeighbors());
 
     SwhId src4 = new SwhId("swh:1:rev:0000000000000000000000000000000000000009");
     Neighbors neighbors4 = new Neighbors(graph, src4, "rev:rev", "backward");
     ArrayList<SwhId> expectedNodes4 = new ArrayList<>();
     expectedNodes4.add(new SwhId("swh:1:rev:0000000000000000000000000000000000000013"));
-    assertEquals(expectedNodes4, neighbors4.getNeighbors());
+    GraphTest.assertEqualsAnyOrder(expectedNodes4, neighbors4.getNeighbors());
   }
 
   @Test
   public void twoNeighbors() {
     Graph graph = getGraph();
 
     SwhId src1 = new SwhId("swh:1:snp:0000000000000000000000000000000000000020");
     Neighbors neighbors1 = new Neighbors(graph, src1, "*", "forward");
     ArrayList<SwhId> expectedNodes1 = new ArrayList<>();
     expectedNodes1.add(new SwhId("swh:1:rel:0000000000000000000000000000000000000010"));
     expectedNodes1.add(new SwhId("swh:1:rev:0000000000000000000000000000000000000009"));
-    assertEquals(expectedNodes1, neighbors1.getNeighbors());
+    GraphTest.assertEqualsAnyOrder(expectedNodes1, neighbors1.getNeighbors());
 
     SwhId src2 = new SwhId("swh:1:dir:0000000000000000000000000000000000000008");
     Neighbors neighbors2 = new Neighbors(graph, src2, "dir:cnt", "forward");
     ArrayList<SwhId> expectedNodes2 = new ArrayList<>();
     expectedNodes2.add(new SwhId("swh:1:cnt:0000000000000000000000000000000000000001"));
     expectedNodes2.add(new SwhId("swh:1:cnt:0000000000000000000000000000000000000007"));
-    assertEquals(expectedNodes2, neighbors2.getNeighbors());
+    GraphTest.assertEqualsAnyOrder(expectedNodes2, neighbors2.getNeighbors());
 
     SwhId src3 = new SwhId("swh:1:cnt:0000000000000000000000000000000000000001");
     Neighbors neighbors3 = new Neighbors(graph, src3, "*", "backward");
     ArrayList<SwhId> expectedNodes3 = new ArrayList<>();
     expectedNodes3.add(new SwhId("swh:1:dir:0000000000000000000000000000000000000008"));
     expectedNodes3.add(new SwhId("swh:1:dir:0000000000000000000000000000000000000002"));
-    assertEquals(expectedNodes3, neighbors3.getNeighbors());
+    GraphTest.assertEqualsAnyOrder(expectedNodes3, neighbors3.getNeighbors());
 
     SwhId src4 = new SwhId("swh:1:rev:0000000000000000000000000000000000000009");
     Neighbors neighbors4 = new Neighbors(graph, src4, "rev:snp,rev:rel", "backward");
     ArrayList<SwhId> expectedNodes4 = new ArrayList<>();
     expectedNodes4.add(new SwhId("swh:1:snp:0000000000000000000000000000000000000020"));
     expectedNodes4.add(new SwhId("swh:1:rel:0000000000000000000000000000000000000010"));
-    assertEquals(expectedNodes4, neighbors4.getNeighbors());
+    GraphTest.assertEqualsAnyOrder(expectedNodes4, neighbors4.getNeighbors());
   }
 
   @Test
   public void threeNeighbors() {
     Graph graph = getGraph();
 
     SwhId src1 = new SwhId("swh:1:dir:0000000000000000000000000000000000000008");
     Neighbors neighbors1 = new Neighbors(graph, src1, "*", "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"));
-    assertEquals(expectedNodes1, neighbors1.getNeighbors());
+    GraphTest.assertEqualsAnyOrder(expectedNodes1, neighbors1.getNeighbors());
 
     SwhId src2 = new SwhId("swh:1:rev:0000000000000000000000000000000000000009");
     Neighbors neighbors2 = new Neighbors(graph, src2, "*", "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"));
-    assertEquals(expectedNodes2, neighbors2.getNeighbors());
+    GraphTest.assertEqualsAnyOrder(expectedNodes2, neighbors2.getNeighbors());
   }
 }
diff --git a/api/server/src/test/java/org/softwareheritage/graph/VisitTest.java b/api/server/src/test/java/org/softwareheritage/graph/VisitTest.java
index a9ad5f6..be0fdb8 100644
--- a/api/server/src/test/java/org/softwareheritage/graph/VisitTest.java
+++ b/api/server/src/test/java/org/softwareheritage/graph/VisitTest.java
@@ -1,531 +1,521 @@
 package org.softwareheritage.graph;
 
 import java.util.ArrayList;
 import java.util.LinkedHashSet;
 
-import org.junit.Assert;
 import org.junit.Test;
-import static org.hamcrest.collection.IsIterableContainingInAnyOrder.containsInAnyOrder;
 
 import org.softwareheritage.graph.Graph;
 import org.softwareheritage.graph.GraphTest;
 import org.softwareheritage.graph.SwhId;
 import org.softwareheritage.graph.SwhPath;
 import org.softwareheritage.graph.algo.Visit;
 
 public class VisitTest extends GraphTest {
   Visit.OutputFmt outputFmt = Visit.OutputFmt.NODES_AND_PATHS;
 
-  private void assertEqualPaths(ArrayList<SwhPath> expecteds, ArrayList<SwhPath> actuals) {
-    Assert.assertThat(expecteds, containsInAnyOrder(actuals.toArray()));
-  }
-
-  private void assertEqualNodes(LinkedHashSet<SwhId> expecteds, LinkedHashSet<SwhId> actuals) {
-    Assert.assertThat(expecteds, containsInAnyOrder(actuals.toArray()));
-  }
-
   private void assertSameNodesFromPaths(ArrayList<SwhPath> paths, LinkedHashSet<SwhId> nodes) {
     LinkedHashSet<SwhId> expectedNodes = new LinkedHashSet<SwhId>();
     for (SwhPath path : paths) {
       for (SwhId node : path.getPath()) {
         expectedNodes.add(node);
       }
     }
-    assertEqualNodes(expectedNodes, nodes);
+    GraphTest.assertEqualsAnyOrder(expectedNodes, nodes);
   }
 
   @Test
   public void forwardFromRoot() {
     Graph graph = getGraph();
     SwhId swhId = new SwhId("swh:1:snp:0000000000000000000000000000000000000020");
     Visit visit = new Visit(graph, swhId, "*", "forward", outputFmt);
     ArrayList<SwhPath> paths = visit.getPaths();
     LinkedHashSet<SwhId> nodes = visit.getNodes();
 
     ArrayList<SwhPath> expectedPaths = new ArrayList<SwhPath>();
     expectedPaths.add(
         new SwhPath(
           "swh:1:snp:0000000000000000000000000000000000000020",
           "swh:1:rev:0000000000000000000000000000000000000009",
           "swh:1:dir:0000000000000000000000000000000000000008",
           "swh:1:cnt:0000000000000000000000000000000000000007"
         ));
     expectedPaths.add(
         new SwhPath(
           "swh:1:snp:0000000000000000000000000000000000000020",
           "swh:1:rev:0000000000000000000000000000000000000009",
           "swh:1:dir:0000000000000000000000000000000000000008",
           "swh:1:cnt:0000000000000000000000000000000000000001"
         ));
     expectedPaths.add(
         new SwhPath(
           "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:snp:0000000000000000000000000000000000000020",
           "swh:1:rev:0000000000000000000000000000000000000009",
           "swh:1:dir:0000000000000000000000000000000000000008",
           "swh:1:dir:0000000000000000000000000000000000000006",
           "swh:1:cnt:0000000000000000000000000000000000000005"
         ));
     expectedPaths.add(
         new SwhPath(
           "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:snp:0000000000000000000000000000000000000020",
           "swh:1:rel:0000000000000000000000000000000000000010",
           "swh:1:rev:0000000000000000000000000000000000000009",
           "swh:1:dir:0000000000000000000000000000000000000008",
           "swh:1:cnt:0000000000000000000000000000000000000007"
         ));
     expectedPaths.add(
         new SwhPath(
           "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: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: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:snp:0000000000000000000000000000000000000020",
           "swh:1:rel:0000000000000000000000000000000000000010",
           "swh:1:rev:0000000000000000000000000000000000000009",
           "swh:1:rev:0000000000000000000000000000000000000003",
           "swh:1:dir:0000000000000000000000000000000000000002",
           "swh:1:cnt:0000000000000000000000000000000000000001"
         ));
 
-    assertEqualPaths(expectedPaths, paths);
+    GraphTest.assertEqualsAnyOrder(expectedPaths, paths);
     assertSameNodesFromPaths(expectedPaths, nodes);
   }
 
   @Test
   public void forwardFromMiddle() {
     Graph graph = getGraph();
     SwhId swhId = new SwhId("swh:1:dir:0000000000000000000000000000000000000012");
     Visit visit = new Visit(graph, swhId, "*", "forward", outputFmt);
     ArrayList<SwhPath> paths = visit.getPaths();
     LinkedHashSet<SwhId> nodes = visit.getNodes();
 
     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"
         ));
 
-    assertEqualPaths(expectedPaths, paths);
+    GraphTest.assertEqualsAnyOrder(expectedPaths, paths);
     assertSameNodesFromPaths(expectedPaths, nodes);
   }
 
   @Test
   public void forwardFromLeaf() {
     Graph graph = getGraph();
     SwhId swhId = new SwhId("swh:1:cnt:0000000000000000000000000000000000000004");
     Visit visit = new Visit(graph, swhId, "*", "forward", outputFmt);
     ArrayList<SwhPath> paths = visit.getPaths();
     LinkedHashSet<SwhId> nodes = visit.getNodes();
 
     ArrayList<SwhPath> expectedPaths = new ArrayList<SwhPath>();
     expectedPaths.add(
         new SwhPath(
           "swh:1:cnt:0000000000000000000000000000000000000004"
         ));
 
-    assertEqualPaths(expectedPaths, paths);
+    GraphTest.assertEqualsAnyOrder(expectedPaths, paths);
     assertSameNodesFromPaths(expectedPaths, nodes);
   }
 
   @Test
   public void backwardFromRoot() {
     Graph graph = getGraph();
     SwhId swhId = new SwhId("swh:1:snp:0000000000000000000000000000000000000020");
     Visit visit = new Visit(graph, swhId, "*", "backward", outputFmt);
     ArrayList<SwhPath> paths = visit.getPaths();
     LinkedHashSet<SwhId> nodes = visit.getNodes();
 
     ArrayList<SwhPath> expectedPaths = new ArrayList<SwhPath>();
     expectedPaths.add(
         new SwhPath(
           "swh:1:snp:0000000000000000000000000000000000000020"
         ));
 
-    assertEqualPaths(expectedPaths, paths);
+    GraphTest.assertEqualsAnyOrder(expectedPaths, paths);
     assertSameNodesFromPaths(expectedPaths, nodes);
   }
 
   @Test
   public void backwardFromMiddle() {
     Graph graph = getGraph();
     SwhId swhId = new SwhId("swh:1:dir:0000000000000000000000000000000000000012");
     Visit visit = new Visit(graph, swhId, "*", "backward", outputFmt);
     ArrayList<SwhPath> paths = visit.getPaths();
     LinkedHashSet<SwhId> nodes = visit.getNodes();
 
     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"
         ));
 
-    assertEqualPaths(expectedPaths, paths);
+    GraphTest.assertEqualsAnyOrder(expectedPaths, paths);
     assertSameNodesFromPaths(expectedPaths, nodes);
   }
 
   @Test
   public void backwardFromLeaf() {
     Graph graph = getGraph();
     SwhId swhId = new SwhId("swh:1:cnt:0000000000000000000000000000000000000004");
     Visit visit = new Visit(graph, swhId, "*", "backward", outputFmt);
     ArrayList<SwhPath> paths = visit.getPaths();
     LinkedHashSet<SwhId> nodes = visit.getNodes();
 
     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"
         ));
     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"
         ));
 
-    assertEqualPaths(expectedPaths, paths);
+    GraphTest.assertEqualsAnyOrder(expectedPaths, paths);
     assertSameNodesFromPaths(expectedPaths, nodes);
   }
 
   @Test
   public void forwardSnpToRev() {
     Graph graph = getGraph();
     SwhId swhId = new SwhId("swh:1:snp:0000000000000000000000000000000000000020");
     Visit visit = new Visit(graph, swhId, "snp:rev", "forward", outputFmt);
     ArrayList<SwhPath> paths = visit.getPaths();
     LinkedHashSet<SwhId> nodes = visit.getNodes();
 
     ArrayList<SwhPath> expectedPaths = new ArrayList<SwhPath>();
     expectedPaths.add(
         new SwhPath(
           "swh:1:snp:0000000000000000000000000000000000000020",
           "swh:1:rev:0000000000000000000000000000000000000009"
         ));
 
-    assertEqualPaths(expectedPaths, paths);
+    GraphTest.assertEqualsAnyOrder(expectedPaths, paths);
     assertSameNodesFromPaths(expectedPaths, nodes);
   }
 
   @Test
   public void forwardRelToRevRevToRev() {
     Graph graph = getGraph();
     SwhId swhId = new SwhId("swh:1:rel:0000000000000000000000000000000000000010");
     Visit visit = new Visit(graph, swhId, "rel:rev,rev:rev", "forward", outputFmt);
     ArrayList<SwhPath> paths = visit.getPaths();
     LinkedHashSet<SwhId> nodes = visit.getNodes();
 
     ArrayList<SwhPath> expectedPaths = new ArrayList<SwhPath>();
     expectedPaths.add(
         new SwhPath(
           "swh:1:rel:0000000000000000000000000000000000000010",
           "swh:1:rev:0000000000000000000000000000000000000009",
           "swh:1:rev:0000000000000000000000000000000000000003"
         ));
 
-    assertEqualPaths(expectedPaths, paths);
+    GraphTest.assertEqualsAnyOrder(expectedPaths, paths);
     assertSameNodesFromPaths(expectedPaths, nodes);
   }
 
   @Test
   public void forwardRevToAllDirToAll() {
     Graph graph = getGraph();
     SwhId swhId = new SwhId("swh:1:rev:0000000000000000000000000000000000000013");
     Visit visit = new Visit(graph, swhId, "rev:*,dir:*", "forward", outputFmt);
     ArrayList<SwhPath> paths = visit.getPaths();
     LinkedHashSet<SwhId> nodes = visit.getNodes();
 
     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"
         ));
 
-    assertEqualPaths(expectedPaths, paths);
+    GraphTest.assertEqualsAnyOrder(expectedPaths, paths);
     assertSameNodesFromPaths(expectedPaths, nodes);
   }
 
   @Test
   public void forwardSnpToAllRevToAll() {
     Graph graph = getGraph();
     SwhId swhId = new SwhId("swh:1:snp:0000000000000000000000000000000000000020");
     Visit visit = new Visit(graph, swhId, "snp:*,rev:*", "forward", outputFmt);
     ArrayList<SwhPath> paths = visit.getPaths();
     LinkedHashSet<SwhId> nodes = visit.getNodes();
 
     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"
         ));
 
-    assertEqualPaths(expectedPaths, paths);
+    GraphTest.assertEqualsAnyOrder(expectedPaths, paths);
     assertSameNodesFromPaths(expectedPaths, nodes);
   }
 
   @Test
   public void forwardNoEdges() {
     Graph graph = getGraph();
     SwhId swhId = new SwhId("swh:1:snp:0000000000000000000000000000000000000020");
     Visit visit = new Visit(graph, swhId, "", "forward", outputFmt);
     ArrayList<SwhPath> paths = visit.getPaths();
     LinkedHashSet<SwhId> nodes = visit.getNodes();
 
     ArrayList<SwhPath> expectedPaths = new ArrayList<SwhPath>();
     expectedPaths.add(
         new SwhPath(
           "swh:1:snp:0000000000000000000000000000000000000020"
         ));
 
-    assertEqualPaths(expectedPaths, paths);
+    GraphTest.assertEqualsAnyOrder(expectedPaths, paths);
     assertSameNodesFromPaths(expectedPaths, nodes);
   }
 
   @Test
   public void backwardRevToRevRevToRel() {
     Graph graph = getGraph();
     SwhId swhId = new SwhId("swh:1:rev:0000000000000000000000000000000000000003");
     Visit visit = new Visit(graph, swhId, "rev:rev,rev:rel", "backward", outputFmt);
     ArrayList<SwhPath> paths = visit.getPaths();
     LinkedHashSet<SwhId> nodes = visit.getNodes();
 
     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"
         ));
 
-    assertEqualPaths(expectedPaths, paths);
+    GraphTest.assertEqualsAnyOrder(expectedPaths, paths);
     assertSameNodesFromPaths(expectedPaths, nodes);
   }
 
   @Test
   public void forwardFromRootNodesOnly() {
     Graph graph = getGraph();
     SwhId swhId = new SwhId("swh:1:snp:0000000000000000000000000000000000000020");
     Visit visit = new Visit(graph, swhId, "*", "forward", Visit.OutputFmt.ONLY_NODES);
     LinkedHashSet<SwhId> nodes = visit.getNodes();
 
     LinkedHashSet<SwhId> expectedNodes = new LinkedHashSet<SwhId>();
     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"));
 
-    assertEqualNodes(expectedNodes, nodes);
+    GraphTest.assertEqualsAnyOrder(expectedNodes, nodes);
   }
 
   @Test
   public void backwardRevToAllNodesOnly() {
     Graph graph = getGraph();
     SwhId swhId = new SwhId("swh:1:rev:0000000000000000000000000000000000000003");
     Visit visit = new Visit(graph, swhId, "rev:*", "backward", Visit.OutputFmt.ONLY_NODES);
     LinkedHashSet<SwhId> nodes = visit.getNodes();
 
     LinkedHashSet<SwhId> expectedNodes = new LinkedHashSet<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"));
 
-    assertEqualNodes(expectedNodes, nodes);
+    GraphTest.assertEqualsAnyOrder(expectedNodes, nodes);
   }
 }