diff --git a/java/src/main/java/org/softwareheritage/graph/Subgraph.java b/java/src/main/java/org/softwareheritage/graph/Subgraph.java
index 65723e3..3e7e7fd 100644
--- a/java/src/main/java/org/softwareheritage/graph/Subgraph.java
+++ b/java/src/main/java/org/softwareheritage/graph/Subgraph.java
@@ -1,222 +1,224 @@
 package org.softwareheritage.graph;
 
 import it.unimi.dsi.big.webgraph.ImmutableGraph;
 import it.unimi.dsi.big.webgraph.LazyLongIterator;
 import it.unimi.dsi.big.webgraph.NodeIterator;
 
 import java.util.NoSuchElementException;
 
-
 public class Subgraph extends ImmutableGraph {
     private final Graph underlyingGraph;
     public final AllowedNodes allowedNodeTypes;
 
     private long nodeCount = -1;
 
     /**
      * Constructor.
      *
      */
     public Subgraph(Graph underlyingGraph, AllowedNodes allowedNodeTypes) {
         this.underlyingGraph = underlyingGraph.copy();
         this.allowedNodeTypes = allowedNodeTypes;
     }
 
     /**
      * Return a flyweight copy of the graph.
      */
     @Override
     public Subgraph copy() {
         return new Subgraph(this.underlyingGraph.copy(), allowedNodeTypes);
     }
 
     @Override
     public boolean randomAccess() {
         return underlyingGraph.randomAccess();
     }
 
     /**
      * Return a transposed version of the graph.
      */
     public Subgraph transpose() {
         return new Subgraph(underlyingGraph.transpose(), allowedNodeTypes);
     }
 
     /**
      * Return a symmetric version of the graph.
      */
     public Subgraph symmetrize() {
         return new Subgraph(underlyingGraph.symmetrize(), allowedNodeTypes);
     }
 
     /**
      * Returns number of nodes in the graph.
      *
      * @return number of nodes in the graph
      */
     @Override
     public long numNodes() {
         if (nodeCount == -1) {
             for (long i = 0; i < underlyingGraph.numNodes(); ++i) {
                 if (nodeExists(i))
                     ++nodeCount;
             }
         }
         return nodeCount;
     }
 
     /**
      * Returns number of edges in the graph.
      *
      * @return number of edges in the graph
      */
     @Override
     public long numArcs() {
         throw new UnsupportedOperationException("Cannot determine the number of arcs in a subgraph");
     }
 
     public long maxNodeNumber() {
         return underlyingGraph.numNodes();
     }
 
     public boolean nodeExists(long node) {
         return allowedNodeTypes.isAllowed(underlyingGraph.getNodeType(node));
     }
 
     /**
      * Returns lazy iterator of successors of a node.
      *
      * @param nodeId node specified as a long id
-     * @return lazy iterator of successors of the node, specified as a <a
-     * href="http://webgraph.di.unimi.it/">WebGraph</a> LazyLongIterator
+     * @return lazy iterator of successors of the node, specified as a
+     *         <a href="http://webgraph.di.unimi.it/">WebGraph</a> LazyLongIterator
      */
     @Override
     public LazyLongIterator successors(long nodeId) {
         if (!nodeExists(nodeId)) {
             throw new IllegalArgumentException("Node " + nodeId + " not in subgraph");
         }
         LazyLongIterator allSuccessors = underlyingGraph.successors(nodeId);
         return new LazyLongIterator() {
             @Override
             public long nextLong() {
                 long neighbor;
                 while ((neighbor = allSuccessors.nextLong()) != -1) {
                     if (nodeExists(neighbor)) {
                         return neighbor;
                     }
                 }
                 return -1;
             }
 
             @Override
             public long skip(final long n) {
                 long i;
-                for (i = 0; i < n && nextLong() != -1; i++) ;
+                for (i = 0; i < n && nextLong() != -1; i++)
+                    ;
                 return i;
             }
         };
     }
 
     /**
      * Returns the outdegree of a node.
      *
      * @param nodeId node specified as a long id
      * @return outdegree of a node
      */
     @Override
     public long outdegree(long nodeId) {
         long deg = 0;
-        for (LazyLongIterator allSuccessors = successors(nodeId); allSuccessors.nextLong() != -1; ++deg);
+        for (LazyLongIterator allSuccessors = successors(nodeId); allSuccessors.nextLong() != -1; ++deg)
+            ;
         return deg;
     }
 
     @Override
     public NodeIterator nodeIterator() {
         return new NodeIterator() {
             final long n = numNodes();
             long i = -1;
             long done = 0;
 
             @Override
             public boolean hasNext() {
                 return done <= n;
             }
 
             @Override
             public long nextLong() {
-                if (!hasNext()) throw new NoSuchElementException();
+                if (!hasNext())
+                    throw new NoSuchElementException();
                 do {
                     ++i;
                     if (i >= underlyingGraph.numNodes())
                         throw new NoSuchElementException();
                 } while (!nodeExists(i));
                 ++done;
                 return i;
             }
 
             @Override
             public long outdegree() {
                 return Subgraph.this.outdegree(i);
             }
 
             @Override
             public LazyLongIterator successors() {
                 return Subgraph.this.successors(i);
             }
         };
     }
 
     /**
      * Returns lazy iterator of predecessors of a node.
      *
      * @param nodeId node specified as a long id
-     * @return lazy iterator of predecessors of the node, specified as a <a
-     * href="http://webgraph.di.unimi.it/">WebGraph</a> LazyLongIterator
+     * @return lazy iterator of predecessors of the node, specified as a
+     *         <a href="http://webgraph.di.unimi.it/">WebGraph</a> LazyLongIterator
      */
     public LazyLongIterator predecessors(long nodeId) {
         return this.transpose().successors(nodeId);
     }
 
     /**
      * Returns the indegree of a node.
      *
      * @param nodeId node specified as a long id
      * @return indegree of a node
      */
     public long indegree(long nodeId) {
         return this.transpose().outdegree(nodeId);
     }
 
     /**
      * Converts {@link SWHID} node to long.
      *
      * @param swhid node specified as a {@link SWHID}
      * @return internal long node id
      * @see SWHID
      */
     public long getNodeId(SWHID swhid) {
         return underlyingGraph.getNodeId(swhid);
     }
 
     /**
      * Converts long id node to {@link SWHID}.
      *
      * @param nodeId node specified as a long id
      * @return external SWHID
      * @see SWHID
      */
     public SWHID getSWHID(long nodeId) {
         return underlyingGraph.getSWHID(nodeId);
     }
 
     /**
      * Returns node type.
      *
      * @param nodeId node specified as a long id
      * @return corresponding node type
      * @see Node.Type
      */
     public Node.Type getNodeType(long nodeId) {
         return underlyingGraph.getNodeType(nodeId);
     }
 }
diff --git a/java/src/main/java/org/softwareheritage/graph/experiments/topology/AveragePaths.java b/java/src/main/java/org/softwareheritage/graph/experiments/topology/AveragePaths.java
index 2fee609..cf9fcd5 100644
--- a/java/src/main/java/org/softwareheritage/graph/experiments/topology/AveragePaths.java
+++ b/java/src/main/java/org/softwareheritage/graph/experiments/topology/AveragePaths.java
@@ -1,194 +1,188 @@
 package org.softwareheritage.graph.experiments.topology;
 
 import com.martiansoftware.jsap.*;
 import it.unimi.dsi.Util;
 import it.unimi.dsi.big.webgraph.LazyLongIterator;
 import it.unimi.dsi.fastutil.BigArrays;
 import it.unimi.dsi.fastutil.longs.LongBigArrays;
 import it.unimi.dsi.logging.ProgressLogger;
 import it.unimi.dsi.util.XoRoShiRo128PlusRandom;
 import org.softwareheritage.graph.*;
 
 import java.io.File;
 import java.io.FileWriter;
 import java.io.IOException;
 import java.io.PrintWriter;
 import java.util.*;
 import java.util.concurrent.*;
 
 public class AveragePaths {
     private final Graph graph;
     private final Subgraph subgraph;
     private final ConcurrentHashMap<Long, Long> result;
     private final String outdir;
 
     public AveragePaths(String graphBasename, String allowedNodes, String outdir) throws IOException {
         System.err.println("Loading graph " + graphBasename + " ...");
         this.graph = new Graph(graphBasename);
         this.subgraph = new Subgraph(this.graph, new AllowedNodes(allowedNodes));
         this.outdir = outdir;
         System.err.println("Graph loaded.");
 
         result = new ConcurrentHashMap<>();
     }
 
     private static JSAPResult parse_args(String[] args) {
         JSAPResult config = null;
         try {
-            SimpleJSAP jsap = new SimpleJSAP(
-                    AveragePaths.class.getName(),
-                    "",
+            SimpleJSAP jsap = new SimpleJSAP(AveragePaths.class.getName(), "",
                     new Parameter[]{
-                            new FlaggedOption("graphPath", JSAP.STRING_PARSER, JSAP.NO_DEFAULT, JSAP.REQUIRED,
-                                    'g', "graph", "Basename of the compressed graph"),
-                            new FlaggedOption("nodeTypes", JSAP.STRING_PARSER, JSAP.NO_DEFAULT, JSAP.REQUIRED,
-                                    's', "nodetypes", "Node type constraints"),
-                            new FlaggedOption("outdir", JSAP.STRING_PARSER, JSAP.NO_DEFAULT, JSAP.REQUIRED,
-                                    'o', "outdir", "Directory where to put the results"),
-                            new FlaggedOption("numThreads", JSAP.INTEGER_PARSER, "32", JSAP.NOT_REQUIRED,
-                                    't', "numthreads", "Number of threads"),
-                    }
-            );
+                            new FlaggedOption("graphPath", JSAP.STRING_PARSER, JSAP.NO_DEFAULT, JSAP.REQUIRED, 'g',
+                                    "graph", "Basename of the compressed graph"),
+                            new FlaggedOption("nodeTypes", JSAP.STRING_PARSER, JSAP.NO_DEFAULT, JSAP.REQUIRED, 's',
+                                    "nodetypes", "Node type constraints"),
+                            new FlaggedOption("outdir", JSAP.STRING_PARSER, JSAP.NO_DEFAULT, JSAP.REQUIRED, 'o',
+                                    "outdir", "Directory where to put the results"),
+                            new FlaggedOption("numThreads", JSAP.INTEGER_PARSER, "32", JSAP.NOT_REQUIRED, 't',
+                                    "numthreads", "Number of threads"),});
 
             config = jsap.parse(args);
             if (jsap.messagePrinted()) {
                 System.exit(1);
             }
         } catch (JSAPException e) {
             e.printStackTrace();
         }
         return config;
     }
 
-
     private void run(int numThreads) throws InterruptedException {
         final long END_OF_QUEUE = -1L;
 
         ArrayBlockingQueue<Long> queue = new ArrayBlockingQueue<>(numThreads);
         ExecutorService service = Executors.newFixedThreadPool(numThreads + 1);
 
         service.submit(() -> {
             try {
                 Graph thread_graph = graph.copy();
                 Subgraph thread_subgraph = subgraph.copy();
 
                 long[][] randomPerm = Util.identity(thread_graph.numNodes());
                 LongBigArrays.shuffle(randomPerm, new XoRoShiRo128PlusRandom());
                 long n = thread_graph.numNodes();
 
                 ProgressLogger pl = new ProgressLogger();
                 pl.expectedUpdates = n;
                 pl.itemsName = "nodes";
                 pl.start("Filling processor queue...");
 
                 for (long j = 0; j < n; ++j) {
                     long node = BigArrays.get(randomPerm, j);
                     if (thread_subgraph.nodeExists(node) && thread_subgraph.outdegree(node) == 0) {
                         queue.put(node);
                     }
                     if (j % 10000 == 0) {
                         printResult();
                     }
                     pl.update();
                 }
             } catch (Exception e) {
                 e.printStackTrace();
             } finally {
                 for (int i = 0; i < numThreads; ++i) {
                     try {
                         queue.put(END_OF_QUEUE);
                     } catch (InterruptedException e) {
                         e.printStackTrace();
                     }
                 }
             }
         });
 
         for (int i = 0; i < numThreads; ++i) {
             service.submit(() -> {
                 try {
                     Subgraph thread_subgraph = subgraph.copy();
                     while (true) {
                         Long node = null;
                         try {
                             node = queue.take();
                         } catch (InterruptedException e) {
                             e.printStackTrace();
                         }
                         if (node == null || node == END_OF_QUEUE) {
                             return;
                         }
 
                         bfsAt(thread_subgraph, node);
                     }
-                } catch (Exception e){
+                } catch (Exception e) {
                     e.printStackTrace();
                 }
             });
         }
 
         service.shutdown();
         service.awaitTermination(365, TimeUnit.DAYS);
     }
 
-    private void bfsAt(Subgraph graph, long srcNodeId)
-    {
+    private void bfsAt(Subgraph graph, long srcNodeId) {
         ArrayDeque<Long> queue = new ArrayDeque<>();
         HashSet<Long> visited = new HashSet<>();
 
         long FRONTIER_MARKER = -1;
 
         queue.addLast(srcNodeId);
         visited.add(srcNodeId);
 
         long distance = 0;
         queue.addLast(FRONTIER_MARKER);
 
         while (!queue.isEmpty()) {
             long currentNodeId = queue.removeFirst();
             // System.err.println("curr: " + currentNodeId);
             if (currentNodeId == FRONTIER_MARKER) {
-                if (queue.isEmpty())  // avoid infinite loops
+                if (queue.isEmpty()) // avoid infinite loops
                     break;
                 ++distance;
                 queue.addLast(FRONTIER_MARKER);
                 continue;
             }
             if (graph.indegree(currentNodeId) == 0) {
                 result.merge(distance, 1L, Long::sum);
             }
 
             LazyLongIterator it = graph.predecessors(currentNodeId);
-            for (long neighborNodeId; (neighborNodeId = it.nextLong()) != -1; ) {
+            for (long neighborNodeId; (neighborNodeId = it.nextLong()) != -1;) {
                 if (!visited.contains(neighborNodeId)) {
                     queue.addLast(neighborNodeId);
                     visited.add(neighborNodeId);
                 }
             }
         }
     }
 
     public void printResult() throws IOException {
         new File(outdir).mkdirs();
 
         PrintWriter f = new PrintWriter(new FileWriter(outdir + "/distribution.txt"));
         TreeMap<Long, Long> sortedDistribution = new TreeMap<>(result);
         for (Map.Entry<Long, Long> entry : sortedDistribution.entrySet()) {
             f.println(entry.getKey() + " " + entry.getValue());
         }
         f.close();
     }
 
     public static void main(String[] args) throws IOException, InterruptedException {
         JSAPResult config = parse_args(args);
 
         String graphPath = config.getString("graphPath");
         String outdir = config.getString("outdir");
         String allowedNodes = config.getString("nodeTypes");
         int numThreads = config.getInt("numThreads");
 
         AveragePaths tp = new AveragePaths(graphPath, allowedNodes, outdir);
         tp.run(numThreads);
         tp.printResult();
     }
 }
diff --git a/java/src/main/java/org/softwareheritage/graph/experiments/topology/ConnectedComponents.java b/java/src/main/java/org/softwareheritage/graph/experiments/topology/ConnectedComponents.java
index 47f89a1..465ba6f 100644
--- a/java/src/main/java/org/softwareheritage/graph/experiments/topology/ConnectedComponents.java
+++ b/java/src/main/java/org/softwareheritage/graph/experiments/topology/ConnectedComponents.java
@@ -1,197 +1,193 @@
 package org.softwareheritage.graph.experiments.topology;
 
 import com.google.common.primitives.Longs;
 import com.martiansoftware.jsap.*;
 import it.unimi.dsi.big.webgraph.LazyLongIterator;
 import it.unimi.dsi.bits.LongArrayBitVector;
 import it.unimi.dsi.fastutil.Arrays;
 import it.unimi.dsi.io.ByteDiskQueue;
 import it.unimi.dsi.logging.ProgressLogger;
 import org.softwareheritage.graph.AllowedNodes;
 import org.softwareheritage.graph.Graph;
 import org.softwareheritage.graph.Subgraph;
 
 import java.io.File;
 import java.io.FileWriter;
 import java.io.IOException;
 import java.io.PrintWriter;
 import java.util.*;
 
 public class ConnectedComponents {
     private Subgraph graph;
 
     private void load_graph(String graphBasename, String nodeTypes) throws IOException {
         System.err.println("Loading graph " + graphBasename + " ...");
         var underlyingGraph = new Graph(graphBasename);
         var underlyingGraphSym = underlyingGraph.symmetrize();
         graph = new Subgraph(underlyingGraphSym, new AllowedNodes(nodeTypes));
         System.err.println("Graph loaded.");
     }
 
     private static JSAPResult parse_args(String[] args) {
         JSAPResult config = null;
         try {
-            SimpleJSAP jsap = new SimpleJSAP(
-                ConnectedComponents.class.getName(),
-                "",
-                new Parameter[] {
-                    new FlaggedOption("graphPath", JSAP.STRING_PARSER, JSAP.NO_DEFAULT, JSAP.REQUIRED,
-                            'g', "graph", "Basename of the compressed graph"),
-                    new FlaggedOption("outdir", JSAP.STRING_PARSER, JSAP.NO_DEFAULT, JSAP.REQUIRED,
-                            'o', "outdir", "Directory where to put the results"),
-                    new FlaggedOption("nodeTypes", JSAP.STRING_PARSER, JSAP.NO_DEFAULT, JSAP.REQUIRED,
-                            'n', "nodetypes", "Allowed node types (comma-separated)"),
-                }
-            );
+            SimpleJSAP jsap = new SimpleJSAP(ConnectedComponents.class.getName(), "",
+                    new Parameter[]{
+                            new FlaggedOption("graphPath", JSAP.STRING_PARSER, JSAP.NO_DEFAULT, JSAP.REQUIRED, 'g',
+                                    "graph", "Basename of the compressed graph"),
+                            new FlaggedOption("outdir", JSAP.STRING_PARSER, JSAP.NO_DEFAULT, JSAP.REQUIRED, 'o',
+                                    "outdir", "Directory where to put the results"),
+                            new FlaggedOption("nodeTypes", JSAP.STRING_PARSER, JSAP.NO_DEFAULT, JSAP.REQUIRED, 'n',
+                                    "nodetypes", "Allowed node types (comma-separated)"),});
 
             config = jsap.parse(args);
             if (jsap.messagePrinted()) {
                 System.exit(1);
             }
         } catch (JSAPException e) {
             e.printStackTrace();
         }
         return config;
     }
 
     private HashMap<Long, Long> /* ArrayList<ArrayList<Long>> */ compute(ProgressLogger pl) throws IOException {
         final long n = graph.numNodes();
         final long maxN = graph.maxNodeNumber();
 
         // Allow enough memory to behave like in-memory queue
-        int bufferSize = (int)Math.min(Arrays.MAX_ARRAY_SIZE & ~0x7, 8L * maxN);
+        int bufferSize = (int) Math.min(Arrays.MAX_ARRAY_SIZE & ~0x7, 8L * maxN);
 
         // Use a disk based queue to store BFS frontier
         final File queueFile = File.createTempFile(ConnectedComponents.class.getSimpleName(), "queue");
         final ByteDiskQueue queue = ByteDiskQueue.createNew(queueFile, bufferSize, true);
         final byte[] byteBuf = new byte[Long.BYTES];
         // WARNING: no 64-bit version of this data-structure, but it can support
         // indices up to 2^37
         LongArrayBitVector visited = LongArrayBitVector.ofLength(maxN);
 
         pl.expectedUpdates = n;
         pl.itemsName = "nodes";
         pl.start("Starting connected components visit...");
 
         // ArrayList<ArrayList<Long>> components = new ArrayList<>();
         HashMap<Long, Long> componentDistribution = new HashMap<>();
 
         var it = graph.nodeIterator();
         while (it.hasNext()) {
             long i = it.nextLong();
 
             if (visited.getBoolean(i))
                 continue;
 
             // ArrayList<Long> component = new ArrayList<>();
             long componentNodes = 0;
 
             queue.enqueue(Longs.toByteArray(i));
             visited.set(i);
 
             while (!queue.isEmpty()) {
                 queue.dequeue(byteBuf);
                 final long currentNode = Longs.fromByteArray(byteBuf);
                 // component.add(currentNode);
                 componentNodes += 1;
 
                 final LazyLongIterator iterator = graph.successors(currentNode);
                 long succ;
                 while ((succ = iterator.nextLong()) != -1) {
                     if (visited.getBoolean(succ))
                         continue;
                     visited.set(succ);
                     queue.enqueue(Longs.toByteArray(succ));
                 }
 
                 pl.update();
             }
 
             /*
              * if (component.size() > 0) { components.add(component); }
              */
             if (componentNodes > 0)
                 componentDistribution.merge(componentNodes, 1L, Long::sum);
         }
         pl.done();
         // return components;
         return componentDistribution;
     }
 
     private static void printDistribution(ArrayList<ArrayList<Long>> components, Formatter out) {
         TreeMap<Long, Long> distribution = new TreeMap<>();
         for (ArrayList<Long> component : components) {
             distribution.merge((long) component.size(), 1L, Long::sum);
         }
 
         for (Map.Entry<Long, Long> entry : distribution.entrySet()) {
             out.format("%d %d\n", entry.getKey(), entry.getValue());
         }
         out.close();
     }
 
     private static void printLargestComponent(ArrayList<ArrayList<Long>> components, Formatter out) {
         int indexLargest = 0;
         for (int i = 1; i < components.size(); ++i) {
             if (components.get(i).size() > components.get(indexLargest).size())
                 indexLargest = i;
         }
 
         ArrayList<Long> component = components.get(indexLargest);
         for (Long node : component) {
             out.format("%d\n", node);
         }
         out.close();
     }
 
     private static void printAllComponents(ArrayList<ArrayList<Long>> components, Formatter out) {
         for (int i = 1; i < components.size(); ++i) {
             ArrayList<Long> component = components.get(i);
             for (Long node : component) {
                 out.format("%d ", node);
             }
             out.format("\n");
         }
         out.close();
     }
 
     public static void main(String[] args) {
         JSAPResult config = parse_args(args);
 
         String graphPath = config.getString("graphPath");
         String outdirPath = config.getString("outdir");
         String nodeTypes = config.getString("nodeTypes");
 
         ConnectedComponents connectedComponents = new ConnectedComponents();
         try {
             connectedComponents.load_graph(graphPath, nodeTypes);
         } catch (IOException e) {
             System.out.println("Could not load graph: " + e);
             System.exit(2);
         }
 
         ProgressLogger logger = new ProgressLogger();
         // noinspection ResultOfMethodCallIgnored
         new File(outdirPath).mkdirs();
         try {
             // ArrayList<ArrayList<Long>> components = connectedComponents.compute(logger);
             // components.sort(Comparator.comparing(ArrayList<Long>::size).reversed());
 
             // printDistribution(components, new Formatter(outdirPath + "/distribution.txt"));
             // printLargestComponent(components, new Formatter(outdirPath + "/largest_component.txt"));
             // printAllComponents(components, new Formatter(outdirPath + "/all_components.txt"));
 
             HashMap<Long, Long> componentDistribution = connectedComponents.compute(logger);
             PrintWriter f = new PrintWriter(new FileWriter(outdirPath + "/distribution.txt"));
             TreeMap<Long, Long> sortedDistribution = new TreeMap<>(componentDistribution);
             for (Map.Entry<Long, Long> entry : sortedDistribution.entrySet()) {
                 f.println(entry.getKey() + " " + entry.getValue());
             }
             f.close();
 
         } catch (IOException e) {
             e.printStackTrace();
         }
         logger.done();
     }
 }
diff --git a/java/src/test/java/org/softwareheritage/graph/GraphTest.java b/java/src/test/java/org/softwareheritage/graph/GraphTest.java
index 345e374..09629a7 100644
--- a/java/src/test/java/org/softwareheritage/graph/GraphTest.java
+++ b/java/src/test/java/org/softwareheritage/graph/GraphTest.java
@@ -1,45 +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 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 static org.hamcrest.collection.IsIterableContainingInAnyOrder.containsInAnyOrder;
 
 public class GraphTest {
     static Graph graph;
 
     @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;
     }
 
     public static SWHID fakeSWHID(String type, int num) {
         return new SWHID(String.format("swh:1:%s:%040d", type, num));
     }
 
     public static <T> void assertEqualsAnyOrder(Collection<T> expecteds, Collection<T> actuals) {
         MatcherAssert.assertThat(expecteds, containsInAnyOrder(actuals.toArray()));
     }
 
     public static ArrayList<Long> lazyLongIteratorToList(LazyLongIterator input) {
         ArrayList<Long> inputList = new ArrayList<>();
         Iterator<Long> inputIt = LazyLongIterators.eager(input);
         inputIt.forEachRemaining(inputList::add);
         return inputList;
     }
 }
diff --git a/java/src/test/java/org/softwareheritage/graph/SubgraphTest.java b/java/src/test/java/org/softwareheritage/graph/SubgraphTest.java
index 70e0417..1f95ebe 100644
--- a/java/src/test/java/org/softwareheritage/graph/SubgraphTest.java
+++ b/java/src/test/java/org/softwareheritage/graph/SubgraphTest.java
@@ -1,110 +1,85 @@
 package org.softwareheritage.graph;
 
-import java.lang.IllegalArgumentException;
 import java.util.*;
 
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
 
 public class SubgraphTest extends GraphTest {
     @Test
     public void noFilter() {
         Graph g = getGraph();
         Subgraph sg = new Subgraph(g, new AllowedNodes("*"));
 
         for (long i = 0; i < g.numNodes(); ++i) {
             Assertions.assertEquals(g.outdegree(i), sg.outdegree(i));
         }
     }
 
     @Test
     public void missingNode() {
         Graph g = getGraph();
         Subgraph sg = new Subgraph(g, new AllowedNodes("dir,ori"));
 
         SWHID rev1 = fakeSWHID("rev", 18);
         Assertions.assertThrows(IllegalArgumentException.class, () -> {
             sg.outdegree(sg.getNodeId(rev1));
         });
         Assertions.assertThrows(IllegalArgumentException.class, () -> {
             sg.successors(sg.getNodeId(rev1));
         });
     }
 
     @Test
     public void outdegreeOnlyDirOri() {
         Graph g = getGraph();
         Subgraph sg = new Subgraph(g, new AllowedNodes("dir,ori"));
 
         SWHID dir1 = fakeSWHID("dir", 17);
         Assertions.assertEquals(2, g.outdegree(g.getNodeId(dir1)));
         Assertions.assertEquals(1, sg.outdegree(sg.getNodeId(dir1)));
 
         SWHID dir2 = fakeSWHID("dir", 6);
         Assertions.assertEquals(2, g.outdegree(g.getNodeId(dir2)));
         Assertions.assertEquals(0, sg.outdegree(sg.getNodeId(dir2)));
 
         SWHID ori1 = fakeSWHID("ori", 21);
         Assertions.assertEquals(1, g.outdegree(g.getNodeId(ori1)));
         Assertions.assertEquals(0, sg.outdegree(sg.getNodeId(ori1)));
     }
 
     @Test
     public void successorsOnlyDirOri() {
         Graph g = getGraph();
         Subgraph sg = new Subgraph(g, new AllowedNodes("dir,ori"));
 
         SWHID dir1 = fakeSWHID("dir", 17);
-        assertEqualsAnyOrder(
-                Collections.singletonList(
-                        sg.getNodeId(fakeSWHID("dir", 16))
-                ),
-                lazyLongIteratorToList(sg.successors(sg.getNodeId(dir1)))
-        );
+        assertEqualsAnyOrder(Collections.singletonList(sg.getNodeId(fakeSWHID("dir", 16))),
+                lazyLongIteratorToList(sg.successors(sg.getNodeId(dir1))));
 
         SWHID dir2 = fakeSWHID("dir", 6);
-        assertEqualsAnyOrder(
-                Collections.emptyList(),
-                lazyLongIteratorToList(sg.successors(sg.getNodeId(dir2)))
-        );
+        assertEqualsAnyOrder(Collections.emptyList(), lazyLongIteratorToList(sg.successors(sg.getNodeId(dir2))));
 
         SWHID ori1 = fakeSWHID("ori", 21);
-        assertEqualsAnyOrder(
-                Collections.emptyList(),
-                lazyLongIteratorToList(sg.successors(sg.getNodeId(ori1)))
-        );
+        assertEqualsAnyOrder(Collections.emptyList(), lazyLongIteratorToList(sg.successors(sg.getNodeId(ori1))));
     }
 
     @Test
     public void nodeIteratorOnlyOriDir() {
         Graph g = getGraph();
         Subgraph sg = new Subgraph(g, new AllowedNodes("dir,ori"));
         ArrayList<Long> nodeList = new ArrayList<>();
         Iterator<Long> nodeIt = sg.nodeIterator();
         nodeIt.forEachRemaining(nodeList::add);
-        assertEqualsAnyOrder(
-                Arrays.asList(
-                        sg.getNodeId(fakeSWHID("ori", 21)),
-                        sg.getNodeId(fakeSWHID("dir", 2)),
-                        sg.getNodeId(fakeSWHID("dir", 6)),
-                        sg.getNodeId(fakeSWHID("dir", 8)),
-                        sg.getNodeId(fakeSWHID("dir", 12)),
-                        sg.getNodeId(fakeSWHID("dir", 16)),
-                        sg.getNodeId(fakeSWHID("dir", 17))
-                ),
-                nodeList
-        );
+        assertEqualsAnyOrder(Arrays.asList(sg.getNodeId(fakeSWHID("ori", 21)), sg.getNodeId(fakeSWHID("dir", 2)),
+                sg.getNodeId(fakeSWHID("dir", 6)), sg.getNodeId(fakeSWHID("dir", 8)),
+                sg.getNodeId(fakeSWHID("dir", 12)), sg.getNodeId(fakeSWHID("dir", 16)),
+                sg.getNodeId(fakeSWHID("dir", 17))), nodeList);
         sg = new Subgraph(g, new AllowedNodes("snp,rel"));
         nodeList = new ArrayList<>();
         nodeIt = sg.nodeIterator();
         nodeIt.forEachRemaining(nodeList::add);
-        assertEqualsAnyOrder(
-                Arrays.asList(
-                        sg.getNodeId(fakeSWHID("snp", 20)),
-                        sg.getNodeId(fakeSWHID("rel", 10)),
-                        sg.getNodeId(fakeSWHID("rel", 19))
-                ),
-                nodeList
-        );
+        assertEqualsAnyOrder(Arrays.asList(sg.getNodeId(fakeSWHID("snp", 20)), sg.getNodeId(fakeSWHID("rel", 10)),
+                sg.getNodeId(fakeSWHID("rel", 19))), nodeList);
     }
 }