diff --git a/api/server/src/main/java/org/softwareheritage/graph/App.java b/api/server/src/main/java/org/softwareheritage/graph/App.java --- a/api/server/src/main/java/org/softwareheritage/graph/App.java +++ b/api/server/src/main/java/org/softwareheritage/graph/App.java @@ -7,12 +7,14 @@ import com.fasterxml.jackson.databind.ObjectMapper; import com.fasterxml.jackson.databind.PropertyNamingStrategy; import io.javalin.Javalin; +import io.javalin.http.Context; import io.javalin.plugin.json.JavalinJackson; import org.softwareheritage.graph.Graph; import org.softwareheritage.graph.SwhId; import org.softwareheritage.graph.algo.Stats; import org.softwareheritage.graph.algo.Visit; +import org.softwareheritage.graph.algo.Walk; public class App { public static void main(String[] args) throws IOException { @@ -38,33 +40,65 @@ Javalin app = Javalin.create().start(5010); - app.get("/stats", ctx -> { - ctx.json(stats); + app.before("/stats/*", ctx -> { checkQueryStrings(ctx, ""); }); + app.before("/visit/*", ctx -> { checkQueryStrings(ctx, "direction|edges"); }); + app.before("/walk/*", ctx -> { checkQueryStrings(ctx, "direction|edges|traversal"); }); + + app.get("/stats/", ctx -> { ctx.json(stats); }); + + // Graph traversal endpoints + // By default the traversal is a forward DFS using all edges + + app.get("/visit/:src", ctx -> { + SwhId src = new SwhId(ctx.pathParam("src")); + String direction = ctx.queryParam("direction", "forward"); + String edgesFmt = ctx.queryParam("edges", "*"); + + Visit visit = new Visit(graph, src, edgesFmt, direction, Visit.OutputFmt.NODES_AND_PATHS); + ctx.json(visit); }); - app.get("/visit/:swh_id", ctx -> { - try { - Map> queryParamMap = ctx.queryParamMap(); - for (String key : queryParamMap.keySet()) { - if (!key.matches("direction|edges|traversal")) { - throw new IllegalArgumentException("Unknown query string: " + key); - } - } + app.get("/visit/nodes/:src", ctx -> { + SwhId src = new SwhId(ctx.pathParam("src")); + String direction = ctx.queryParam("direction", "forward"); + String edgesFmt = ctx.queryParam("edges", "*"); - SwhId swhId = new SwhId(ctx.pathParam("swh_id")); + Visit visit = new Visit(graph, src, edgesFmt, direction, Visit.OutputFmt.ONLY_NODES); + ctx.json(visit.getNodes()); + }); - // By default, traversal is a forward DFS using all edges - String traversal = ctx.queryParam("traversal", "dfs"); - String direction = ctx.queryParam("direction", "forward"); - String edges = ctx.queryParam("edges", "all"); + app.get("/visit/paths/:src", ctx -> { + SwhId src = new SwhId(ctx.pathParam("src")); + String direction = ctx.queryParam("direction", "forward"); + String edgesFmt = ctx.queryParam("edges", "*"); - ctx.json(new Visit(graph, swhId, edges, traversal, direction)); - } catch (IllegalArgumentException e) { - ctx.status(400); - ctx.result(e.getMessage()); - } + Visit visit = new Visit(graph, src, edgesFmt, direction, Visit.OutputFmt.ONLY_PATHS); + ctx.json(visit.getPaths()); }); - app.error(404, ctx -> { ctx.result("Not found"); }); + app.get("/walk/:src/:dst", ctx -> { + SwhId src = new SwhId(ctx.pathParam("src")); + String dstFmt = ctx.pathParam("dst"); + String direction = ctx.queryParam("direction", "forward"); + String edgesFmt = ctx.queryParam("edges", "*"); + String traversal = ctx.queryParam("traversal", "dfs"); + + Walk walk = new Walk(graph, src, dstFmt, edgesFmt, direction, traversal); + ctx.json(walk.getPath()); + }); + + app.exception(IllegalArgumentException.class, (e, ctx) -> { + ctx.status(400); + ctx.result(e.getMessage()); + }); + } + + private static void checkQueryStrings(Context ctx, String allowedFmt) { + Map> queryParamMap = ctx.queryParamMap(); + for (String key : queryParamMap.keySet()) { + if (!key.matches(allowedFmt)) { + throw new IllegalArgumentException("Unknown query string: " + key); + } + } } } diff --git a/api/server/src/main/java/org/softwareheritage/graph/Edges.java b/api/server/src/main/java/org/softwareheritage/graph/Edges.java new file mode 100644 --- /dev/null +++ b/api/server/src/main/java/org/softwareheritage/graph/Edges.java @@ -0,0 +1,47 @@ +package org.softwareheritage.graph; + +import java.util.ArrayList; + +import org.softwareheritage.graph.Node; + +public class Edges { + boolean[][] allowed; + + public Edges(String edgesFmt) { + int nbNodeTypes = Node.Type.values().length; + this.allowed = new boolean[nbNodeTypes][nbNodeTypes]; + // Special values (null, empty, "*") + if (edgesFmt == null || edgesFmt.isEmpty()) { + return; + } + if (edgesFmt.equals("*")) { + for (int i = 0; i < nbNodeTypes; i++) { + for (int j = 0; j < nbNodeTypes; j++) { + allowed[i][j] = true; + } + } + return; + } + + // Format: "src1:dst1,src2:dst2,[...]" + String[] edgeTypes = edgesFmt.split(","); + for (String edgeType : edgeTypes) { + String[] nodeTypes = edgeType.split(":"); + if (nodeTypes.length != 2) { + throw new IllegalArgumentException("Cannot parse edge type: " + edgeType); + } + + ArrayList srcTypes = Node.Type.parse(nodeTypes[0]); + ArrayList dstTypes = Node.Type.parse(nodeTypes[1]); + for (Node.Type srcType : srcTypes) { + for (Node.Type dstType : dstTypes) { + allowed[srcType.ordinal()][dstType.ordinal()] = true; + } + } + } + } + + public boolean isAllowed(Node.Type currentType, Node.Type neighborType) { + return allowed[currentType.ordinal()][neighborType.ordinal()]; + } +} diff --git a/api/server/src/main/java/org/softwareheritage/graph/Node.java b/api/server/src/main/java/org/softwareheritage/graph/Node.java new file mode 100644 --- /dev/null +++ b/api/server/src/main/java/org/softwareheritage/graph/Node.java @@ -0,0 +1,32 @@ +package org.softwareheritage.graph; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +public class Node { + public enum Type { + CNT, + DIR, + REL, + REV, + SNP; + + public static Node.Type fromStr(String strType) { + return Node.Type.valueOf(strType.toUpperCase()); + } + + public static ArrayList parse(String strType) { + ArrayList types = new ArrayList<>(); + + if (strType.equals("*")) { + List nodeTypes = Arrays.asList(Node.Type.values()); + types.addAll(nodeTypes); + } else { + types.add(Node.Type.fromStr(strType)); + } + + return types; + } + } +} diff --git a/api/server/src/main/java/org/softwareheritage/graph/SwhId.java b/api/server/src/main/java/org/softwareheritage/graph/SwhId.java --- a/api/server/src/main/java/org/softwareheritage/graph/SwhId.java +++ b/api/server/src/main/java/org/softwareheritage/graph/SwhId.java @@ -2,11 +2,13 @@ import com.fasterxml.jackson.annotation.JsonValue; +import org.softwareheritage.graph.Node; + public class SwhId { public static final int HASH_LENGTH = 40; String swhId; - String type; + Node.Type type; String hash; // SWH ID format: 'swh:1:type:hash' @@ -19,10 +21,11 @@ throw new IllegalArgumentException("Expected SWH ID format to be 'swh:1:type:hash', got: " + swhId); } - this.type = parts[2]; + String type = parts[2]; if (!type.matches("cnt|dir|rel|rev|snp")) { throw new IllegalArgumentException("Unknown SWH ID type in: " + swhId); } + this.type = Node.Type.fromStr(type); this.hash = parts[3]; if (!hash.matches("[0-9a-f]{" + HASH_LENGTH + "}")) { @@ -40,6 +43,11 @@ } @Override + public int hashCode() { + return swhId.hashCode(); + } + + @Override public String toString() { return swhId; } @@ -49,7 +57,7 @@ return swhId; } - public String getType() { + public Node.Type getType() { return type; } diff --git a/api/server/src/main/java/org/softwareheritage/graph/SwhPath.java b/api/server/src/main/java/org/softwareheritage/graph/SwhPath.java --- a/api/server/src/main/java/org/softwareheritage/graph/SwhPath.java +++ b/api/server/src/main/java/org/softwareheritage/graph/SwhPath.java @@ -1,6 +1,7 @@ package org.softwareheritage.graph; import java.util.ArrayList; +import java.util.Collections; import com.fasterxml.jackson.annotation.JsonValue; @@ -44,6 +45,10 @@ return path.size(); } + public void reverse() { + Collections.reverse(path); + } + @Override public boolean equals(Object otherObj) { if (otherObj == this) return true; diff --git a/api/server/src/main/java/org/softwareheritage/graph/algo/Visit.java b/api/server/src/main/java/org/softwareheritage/graph/algo/Visit.java --- a/api/server/src/main/java/org/softwareheritage/graph/algo/Visit.java +++ b/api/server/src/main/java/org/softwareheritage/graph/algo/Visit.java @@ -1,46 +1,59 @@ package org.softwareheritage.graph.algo; import java.util.ArrayList; +import java.util.LinkedHashSet; import java.util.Stack; import it.unimi.dsi.big.webgraph.LazyLongIterator; +import org.softwareheritage.graph.Edges; import org.softwareheritage.graph.Graph; +import org.softwareheritage.graph.Node; import org.softwareheritage.graph.SwhId; import org.softwareheritage.graph.SwhPath; public class Visit { + public enum OutputFmt { ONLY_NODES, ONLY_PATHS, NODES_AND_PATHS } + Graph graph; boolean useTransposed; - String allowedEdges; - Stack currentPath; + Edges edges; + + // LinkedHashSet is necessary to preserve insertion order + LinkedHashSet nodes; ArrayList paths; + Stack currentPath; - public Visit(Graph graph, SwhId swhId, String allowedEdges, String algorithm, String direction) { - if (!algorithm.matches("dfs|bfs")) { - throw new IllegalArgumentException("Unknown traversal algorithm: " + algorithm); - } + public Visit(Graph graph, SwhId src, String edgesFmt, String direction, OutputFmt output) { if (!direction.matches("forward|backward")) { throw new IllegalArgumentException("Unknown traversal direction: " + direction); } this.graph = graph; this.useTransposed = (direction.equals("backward")); - this.allowedEdges = allowedEdges; + this.edges = new Edges(edgesFmt); + this.nodes = new LinkedHashSet(); this.paths = new ArrayList(); this.currentPath = new Stack(); - if (algorithm.equals("dfs")) { - dfs(graph.getNodeId(swhId)); + long nodeId = graph.getNodeId(src); + if (output == OutputFmt.ONLY_NODES) { + dfsOutputOnlyNodes(nodeId); + } else { + dfs(nodeId); } } - // Allow Jackson JSON to only serialize the 'paths' field + public LinkedHashSet getNodes() { + return nodes; + } + public ArrayList getPaths() { return paths; } private void dfs(long currentNodeId) { + nodes.add(graph.getSwhId(currentNodeId)); currentPath.push(currentNodeId); long degree = graph.degree(currentNodeId, useTransposed); @@ -49,7 +62,9 @@ while (degree-- > 0) { long neighborNodeId = neighbors.nextLong(); - if (isEdgeAllowed(currentNodeId, neighborNodeId)) { + Node.Type currentNodeType = graph.getSwhId(currentNodeId).getType(); + Node.Type neighborNodeType = graph.getSwhId(neighborNodeId).getType(); + if (edges.isAllowed(currentNodeType, neighborNodeType)) { dfs(neighborNodeId); visitedNeighbors++; } @@ -66,15 +81,18 @@ currentPath.pop(); } - private boolean isEdgeAllowed(long currentNodeId, long neighborNodeId) { - if (allowedEdges.equals("all")) { - return true; - } + private void dfsOutputOnlyNodes(long currentNodeId) { + nodes.add(graph.getSwhId(currentNodeId)); + long degree = graph.degree(currentNodeId, useTransposed); + LazyLongIterator neighbors = graph.neighbors(currentNodeId, useTransposed); - String currentType = graph.getSwhId(currentNodeId).getType(); - String neighborType = graph.getSwhId(neighborNodeId).getType(); - String edgeType = currentType + ":" + neighborType; - String edgeTypeRev = neighborType + ":" + currentType; - return allowedEdges.contains(edgeType) || allowedEdges.contains(edgeTypeRev); + while (degree-- > 0) { + long neighborNodeId = neighbors.nextLong(); + Node.Type currentNodeType = graph.getSwhId(currentNodeId).getType(); + Node.Type neighborNodeType = graph.getSwhId(neighborNodeId).getType(); + if (edges.isAllowed(currentNodeType, neighborNodeType)) { + dfsOutputOnlyNodes(neighborNodeId); + } + } } } diff --git a/api/server/src/main/java/org/softwareheritage/graph/algo/Walk.java b/api/server/src/main/java/org/softwareheritage/graph/algo/Walk.java new file mode 100644 --- /dev/null +++ b/api/server/src/main/java/org/softwareheritage/graph/algo/Walk.java @@ -0,0 +1,148 @@ +package org.softwareheritage.graph.algo; + +import java.util.Stack; +import java.util.Queue; +import java.util.LinkedList; + +import it.unimi.dsi.big.webgraph.LazyLongIterator; +import it.unimi.dsi.bits.LongArrayBitVector; +import it.unimi.dsi.fastutil.longs.LongBigArrays; + +import org.softwareheritage.graph.Edges; +import org.softwareheritage.graph.Graph; +import org.softwareheritage.graph.Node; +import org.softwareheritage.graph.SwhId; +import org.softwareheritage.graph.SwhPath; + +public class Walk { + Graph graph; + boolean useTransposed; + Edges edges; + + SwhPath path; + long[][] nodeParent; + + public Walk( + Graph graph, SwhId src, String dstFmt, String edgesFmt, String direction, String traversal) { + if (!traversal.matches("dfs|bfs")) { + throw new IllegalArgumentException("Unknown traversal algorithm: " + traversal); + } + if (!direction.matches("forward|backward")) { + throw new IllegalArgumentException("Unknown traversal direction: " + direction); + } + + this.graph = graph; + this.useTransposed = (direction.equals("backward")); + this.edges = new Edges(edgesFmt); + this.path = new SwhPath(); + this.nodeParent = LongBigArrays.newBigArray(graph.getNbNodes()); + LongBigArrays.fill(nodeParent, -1); + + long srcNodeId = graph.getNodeId(src); + long dstNodeId; + if (traversal.equals("dfs")) { + dstNodeId = dfs(srcNodeId, dstFmt); + } else { + dstNodeId = bfs(srcNodeId, dstFmt); + } + + if (dstNodeId == -1) { + throw new IllegalArgumentException("Unable to find destination point: " + dstFmt); + } else { + backtracking(srcNodeId, dstNodeId); + } + } + + public SwhPath getPath() { + return path; + } + + private void backtracking(long srcNodeId, long dstNodeId) { + long currentNodeId = dstNodeId; + while (currentNodeId != srcNodeId) { + path.add(graph.getSwhId(currentNodeId)); + currentNodeId = LongBigArrays.get(nodeParent, currentNodeId); + } + path.add(graph.getSwhId(srcNodeId)); + path.reverse(); + } + + private long dfs(long srcNodeId, String dstFmt) { + Stack stack = new Stack(); + LongArrayBitVector visited = LongArrayBitVector.ofLength(graph.getNbNodes()); + + stack.push(srcNodeId); + visited.set(srcNodeId); + + while (!stack.isEmpty()) { + long currentNodeId = stack.pop(); + SwhId currentSwhId = graph.getSwhId(currentNodeId); + if (isDestinationNode(currentSwhId, dstFmt)) { + return currentNodeId; + } + + long degree = graph.degree(currentNodeId, useTransposed); + LazyLongIterator neighbors = graph.neighbors(currentNodeId, useTransposed); + + while (degree-- > 0) { + long neighborNodeId = neighbors.nextLong(); + SwhId neighborSwhId = graph.getSwhId(neighborNodeId); + if (!visited.getBoolean(neighborNodeId) + && edges.isAllowed(currentSwhId.getType(), neighborSwhId.getType())) { + stack.push(neighborNodeId); + visited.set(neighborNodeId); + LongBigArrays.set(nodeParent, neighborNodeId, currentNodeId); + } + } + } + + return -1; + } + + private long bfs(long srcNodeId, String dstFmt) { + Queue queue = new LinkedList(); + LongArrayBitVector visited = LongArrayBitVector.ofLength(graph.getNbNodes()); + + queue.add(srcNodeId); + visited.set(srcNodeId); + + while (!queue.isEmpty()) { + long currentNodeId = queue.poll(); + SwhId currentSwhId = graph.getSwhId(currentNodeId); + if (isDestinationNode(currentSwhId, dstFmt)) { + return currentNodeId; + } + + long degree = graph.degree(currentNodeId, useTransposed); + LazyLongIterator neighbors = graph.neighbors(currentNodeId, useTransposed); + + while (degree-- > 0) { + long neighborNodeId = neighbors.nextLong(); + SwhId neighborSwhId = graph.getSwhId(neighborNodeId); + if (!visited.getBoolean(neighborNodeId) + && edges.isAllowed(currentSwhId.getType(), neighborSwhId.getType())) { + queue.add(neighborNodeId); + visited.set(neighborNodeId); + LongBigArrays.set(nodeParent, neighborNodeId, currentNodeId); + } + } + } + + return -1; + } + + private boolean isDestinationNode(SwhId swhId, String dstFmt) { + // dstFmt is either a SwhId... + if (swhId.toString().equals(dstFmt)) { + return true; + } + + // ...or a Node.Type + try { + Node.Type dstType = Node.Type.fromStr(dstFmt); + return (swhId.getType().equals(dstType)); + } catch (IllegalArgumentException e) { + return false; + } + } +} diff --git a/api/server/src/test/java/org/softwareheritage/graph/EdgesTest.java b/api/server/src/test/java/org/softwareheritage/graph/EdgesTest.java new file mode 100644 --- /dev/null +++ b/api/server/src/test/java/org/softwareheritage/graph/EdgesTest.java @@ -0,0 +1,112 @@ +package org.softwareheritage.graph; + +import java.util.ArrayList; + +import org.junit.Test; +import static org.junit.Assert.assertTrue; + +import org.softwareheritage.graph.Edges; +import org.softwareheritage.graph.Node; + +public class EdgesTest { + 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(Edges edges, ArrayList 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; + } + } + + assertTrue("Edge type: " + src + " -> " + dst, isAllowed == isExpected); + } + } + } + + @Test + public void dirToDirDirToCntEdges() { + Edges edges = new Edges("dir:dir,dir:cnt"); + ArrayList 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() { + Edges edges = new Edges("rel:rev,rev:rev,rev:dir"); + ArrayList 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() { + Edges edges = new Edges("rev:*,dir:dir"); + ArrayList 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() { + Edges edges = new Edges("*:cnt"); + ArrayList 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() { + Edges edges = new Edges("*:*"); + Edges edges2 = new Edges("*"); + ArrayList 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); + assertEdgeRestriction(edges2, expected); + } + + @Test + public void noEdges() { + Edges edges = new Edges(""); + Edges edges2 = new Edges(null); + ArrayList expected = new ArrayList<>(); + assertEdgeRestriction(edges, expected); + assertEdgeRestriction(edges2, expected); + } +} diff --git a/api/server/src/test/java/org/softwareheritage/graph/VisitTest.java b/api/server/src/test/java/org/softwareheritage/graph/VisitTest.java --- a/api/server/src/test/java/org/softwareheritage/graph/VisitTest.java +++ b/api/server/src/test/java/org/softwareheritage/graph/VisitTest.java @@ -17,11 +17,13 @@ Assert.assertThat(expecteds, containsInAnyOrder(actuals.toArray())); } + Visit.OutputFmt outputFmt = Visit.OutputFmt.NODES_AND_PATHS; + @Test public void dfsForwardFromRoot() { Graph graph = getGraph(); SwhId swhId = new SwhId("swh:1:snp:0000000000000000000000000000000000000020"); - Visit visit = new Visit(graph, swhId, "all", "dfs", "forward"); + Visit visit = new Visit(graph, swhId, "*", "forward", outputFmt); ArrayList paths = visit.getPaths(); ArrayList expectedPaths = new ArrayList(); @@ -114,7 +116,7 @@ public void dfsForwardFromMiddle() { Graph graph = getGraph(); SwhId swhId = new SwhId("swh:1:dir:0000000000000000000000000000000000000012"); - Visit visit = new Visit(graph, swhId, "all", "dfs", "forward"); + Visit visit = new Visit(graph, swhId, "*", "forward", outputFmt); ArrayList paths = visit.getPaths(); ArrayList expectedPaths = new ArrayList(); @@ -157,7 +159,7 @@ public void dfsForwardFromLeaf() { Graph graph = getGraph(); SwhId swhId = new SwhId("swh:1:cnt:0000000000000000000000000000000000000004"); - Visit visit = new Visit(graph, swhId, "all", "dfs", "forward"); + Visit visit = new Visit(graph, swhId, "*", "forward", outputFmt); ArrayList paths = visit.getPaths(); ArrayList expectedPaths = new ArrayList(); @@ -173,7 +175,7 @@ public void dfsBackwardFromRoot() { Graph graph = getGraph(); SwhId swhId = new SwhId("swh:1:snp:0000000000000000000000000000000000000020"); - Visit visit = new Visit(graph, swhId, "all", "dfs", "backward"); + Visit visit = new Visit(graph, swhId, "*", "backward", outputFmt); ArrayList paths = visit.getPaths(); ArrayList expectedPaths = new ArrayList(); @@ -189,7 +191,7 @@ public void dfsBackwardFromMiddle() { Graph graph = getGraph(); SwhId swhId = new SwhId("swh:1:dir:0000000000000000000000000000000000000012"); - Visit visit = new Visit(graph, swhId, "all", "dfs", "backward"); + Visit visit = new Visit(graph, swhId, "*", "backward", outputFmt); ArrayList paths = visit.getPaths(); ArrayList expectedPaths = new ArrayList(); @@ -208,7 +210,7 @@ public void dfsBackwardFromLeaf() { Graph graph = getGraph(); SwhId swhId = new SwhId("swh:1:cnt:0000000000000000000000000000000000000004"); - Visit visit = new Visit(graph, swhId, "all", "dfs", "backward"); + Visit visit = new Visit(graph, swhId, "*", "backward", outputFmt); ArrayList paths = visit.getPaths(); ArrayList expectedPaths = new ArrayList(); @@ -254,10 +256,10 @@ } @Test - public void dfsForwardOnlySnpRevAllowed() { + public void dfsForwardSnpToRev() { Graph graph = getGraph(); SwhId swhId = new SwhId("swh:1:snp:0000000000000000000000000000000000000020"); - Visit visit = new Visit(graph, swhId, "snp:rev", "dfs", "forward"); + Visit visit = new Visit(graph, swhId, "snp:rev", "forward", outputFmt); ArrayList paths = visit.getPaths(); ArrayList expectedPaths = new ArrayList(); @@ -271,10 +273,10 @@ } @Test - public void dfsForwardOnlyRevRelAllowed() { + public void dfsForwardRelToRevRevToRev() { Graph graph = getGraph(); SwhId swhId = new SwhId("swh:1:rel:0000000000000000000000000000000000000010"); - Visit visit = new Visit(graph, swhId, "rel:rev,rev:rev", "dfs", "forward"); + Visit visit = new Visit(graph, swhId, "rel:rev,rev:rev", "forward", outputFmt); ArrayList paths = visit.getPaths(); ArrayList expectedPaths = new ArrayList(); @@ -289,10 +291,10 @@ } @Test - public void dfsForwardOnlyRevDirCntAllowed() { + public void dfsForwardRevToAllDirToAll() { Graph graph = getGraph(); SwhId swhId = new SwhId("swh:1:rev:0000000000000000000000000000000000000013"); - Visit visit = new Visit(graph, swhId, "rev:rev,rev:dir,dir:dir,dir:cnt", "dfs", "forward"); + Visit visit = new Visit(graph, swhId, "rev:*,dir:*", "forward", outputFmt); ArrayList paths = visit.getPaths(); ArrayList expectedPaths = new ArrayList(); @@ -375,10 +377,40 @@ } @Test - public void dfsForwardNoEdgesAllowed() { + public void dfsForwardSnpToAllRevToAll() { Graph graph = getGraph(); SwhId swhId = new SwhId("swh:1:snp:0000000000000000000000000000000000000020"); - Visit visit = new Visit(graph, swhId, "", "dfs", "forward"); + Visit visit = new Visit(graph, swhId, "snp:*,rev:*", "forward", outputFmt); + ArrayList paths = visit.getPaths(); + + ArrayList expectedPaths = new ArrayList(); + 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" + )); + + assertEqualSwhPaths(expectedPaths, paths); + } + + @Test + public void dfsForwardNoEdges() { + Graph graph = getGraph(); + SwhId swhId = new SwhId("swh:1:snp:0000000000000000000000000000000000000020"); + Visit visit = new Visit(graph, swhId, "", "forward", outputFmt); ArrayList paths = visit.getPaths(); ArrayList expectedPaths = new ArrayList(); @@ -391,10 +423,10 @@ } @Test - public void dfsBackwardOnlyRevRelAllowed() { + public void dfsBackwardRevToRevRevToRel() { Graph graph = getGraph(); SwhId swhId = new SwhId("swh:1:rev:0000000000000000000000000000000000000003"); - Visit visit = new Visit(graph, swhId, "rev:rev,rev:rel", "dfs", "backward"); + Visit visit = new Visit(graph, swhId, "rev:rev,rev:rel", "backward", outputFmt); ArrayList paths = visit.getPaths(); ArrayList expectedPaths = new ArrayList(); @@ -415,24 +447,4 @@ assertEqualSwhPaths(expectedPaths, paths); } - - @Test - public void dfsBackwardAllowedEdgesNotOrderSensitive() { - Graph graph = getGraph(); - SwhId swhId = new SwhId("swh:1:cnt:0000000000000000000000000000000000000004"); - Visit visit1 = new Visit(graph, swhId, "cnt:dir", "dfs", "backward"); - Visit visit2 = new Visit(graph, swhId, "dir:cnt", "dfs", "backward"); - ArrayList paths1 = visit1.getPaths(); - ArrayList paths2 = visit2.getPaths(); - - ArrayList expectedPaths = new ArrayList(); - expectedPaths.add( - new SwhPath( - "swh:1:cnt:0000000000000000000000000000000000000004", - "swh:1:dir:0000000000000000000000000000000000000006" - )); - - assertEqualSwhPaths(expectedPaths, paths1); - assertEqualSwhPaths(expectedPaths, paths2); - } }