diff --git a/java/src/main/java/org/softwareheritage/graph/rpc/NodePropertyBuilder.java b/java/src/main/java/org/softwareheritage/graph/rpc/NodePropertyBuilder.java --- a/java/src/main/java/org/softwareheritage/graph/rpc/NodePropertyBuilder.java +++ b/java/src/main/java/org/softwareheritage/graph/rpc/NodePropertyBuilder.java @@ -130,13 +130,22 @@ case REL: ReleaseData.Builder relBuilder = ReleaseData.newBuilder(); if (mask.relAuthor) { - relBuilder.setAuthor(graph.getAuthorId(node)); + Long author = graph.getAuthorId(node); + if (author != null) { + relBuilder.setAuthor(author); + } } if (mask.relAuthorDate) { - relBuilder.setAuthorDate(graph.getAuthorTimestamp(node)); + Long date = graph.getAuthorTimestamp(node); + if (date != null) { + relBuilder.setAuthorDate(date); + } } if (mask.relAuthorDateOffset) { - relBuilder.setAuthorDateOffset(graph.getAuthorTimestampOffset(node)); + Short offset = graph.getAuthorTimestampOffset(node); + if (offset != null) { + relBuilder.setAuthorDateOffset(offset); + } } if (mask.relName) { byte[] msg = graph.getMessage(node); diff --git a/java/src/test/java/org/softwareheritage/graph/GraphTest.java b/java/src/test/java/org/softwareheritage/graph/GraphTest.java --- a/java/src/test/java/org/softwareheritage/graph/GraphTest.java +++ b/java/src/test/java/org/softwareheritage/graph/GraphTest.java @@ -28,6 +28,7 @@ static SwhBidirectionalGraph graph; final protected String TEST_ORIGIN_ID = "swh:1:ori:83404f995118bd25774f4ac14422a8f175e7a054"; + final protected String TEST_ORIGIN_ID2 = "swh:1:ori:8f50d3f60eae370ddbf85c86219c55108a350165"; @BeforeAll public static void setUp() throws IOException { diff --git a/java/src/test/java/org/softwareheritage/graph/SubgraphTest.java b/java/src/test/java/org/softwareheritage/graph/SubgraphTest.java --- a/java/src/test/java/org/softwareheritage/graph/SubgraphTest.java +++ b/java/src/test/java/org/softwareheritage/graph/SubgraphTest.java @@ -78,15 +78,18 @@ ArrayList nodeList = new ArrayList<>(); Iterator nodeIt = sg.nodeIterator(); nodeIt.forEachRemaining(nodeList::add); - assertEqualsAnyOrder(Arrays.asList(sg.getNodeId(new SWHID(TEST_ORIGIN_ID)), 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(new SWHID(TEST_ORIGIN_ID)), sg.getNodeId(new SWHID(TEST_ORIGIN_ID2)), + 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); + sg.getNodeId(fakeSWHID("rel", 19)), sg.getNodeId(fakeSWHID("rel", 21)), + sg.getNodeId(fakeSWHID("snp", 22))), nodeList); } } diff --git a/java/src/test/java/org/softwareheritage/graph/rpc/CountEdgesTest.java b/java/src/test/java/org/softwareheritage/graph/rpc/CountEdgesTest.java --- a/java/src/test/java/org/softwareheritage/graph/rpc/CountEdgesTest.java +++ b/java/src/test/java/org/softwareheritage/graph/rpc/CountEdgesTest.java @@ -83,21 +83,21 @@ public void backwardFromMiddle() { CountResponse actual = client.countEdges( getTraversalRequestBuilder(fakeSWHID("dir", 12)).setDirection(GraphDirection.BACKWARD).build()); - assertEquals(3, actual.getCount()); + assertEquals(6, actual.getCount()); } @Test public void backwardFromLeaf() { CountResponse actual = client.countEdges( getTraversalRequestBuilder(fakeSWHID("cnt", 4)).setDirection(GraphDirection.BACKWARD).build()); - assertEquals(12, actual.getCount()); + assertEquals(17, actual.getCount()); } @Test public void backwardRevToRevRevToRel() { CountResponse actual = client.countEdges(getTraversalRequestBuilder(fakeSWHID("rev", 3)) .setEdges("rev:rev,rev:rel").setDirection(GraphDirection.BACKWARD).build()); - assertEquals(5, actual.getCount()); + assertEquals(6, actual.getCount()); } @Test diff --git a/java/src/test/java/org/softwareheritage/graph/rpc/CountNodesTest.java b/java/src/test/java/org/softwareheritage/graph/rpc/CountNodesTest.java --- a/java/src/test/java/org/softwareheritage/graph/rpc/CountNodesTest.java +++ b/java/src/test/java/org/softwareheritage/graph/rpc/CountNodesTest.java @@ -73,21 +73,21 @@ public void backwardFromMiddle() { CountResponse actual = client.countNodes( getTraversalRequestBuilder(fakeSWHID("dir", 12)).setDirection(GraphDirection.BACKWARD).build()); - assertEquals(4, actual.getCount()); + assertEquals(7, actual.getCount()); } @Test public void backwardFromLeaf() { CountResponse actual = client.countNodes( getTraversalRequestBuilder(fakeSWHID("cnt", 4)).setDirection(GraphDirection.BACKWARD).build()); - assertEquals(11, actual.getCount()); + assertEquals(14, actual.getCount()); } @Test public void backwardRevToRevRevToRel() { CountResponse actual = client.countNodes(getTraversalRequestBuilder(fakeSWHID("rev", 3)) .setEdges("rev:rev,rev:rel").setDirection(GraphDirection.BACKWARD).build()); - assertEquals(6, actual.getCount()); + assertEquals(7, actual.getCount()); } @ParameterizedTest @@ -95,7 +95,7 @@ public void backwardRevToRevRevToRelWithLimit(int limit) { CountResponse actual = client.countNodes(getTraversalRequestBuilder(fakeSWHID("rev", 3)) .setEdges("rev:rev,rev:rel").setDirection(GraphDirection.BACKWARD).setMaxMatchingNodes(limit).build()); - assertEquals(Math.min(limit, 6), actual.getCount()); + assertEquals(Math.min(limit, 7), actual.getCount()); } @Test diff --git a/java/src/test/java/org/softwareheritage/graph/rpc/FindPathBetweenTest.java b/java/src/test/java/org/softwareheritage/graph/rpc/FindPathBetweenTest.java --- a/java/src/test/java/org/softwareheritage/graph/rpc/FindPathBetweenTest.java +++ b/java/src/test/java/org/softwareheritage/graph/rpc/FindPathBetweenTest.java @@ -157,7 +157,7 @@ Path p = client.findPathBetween(getRequestBuilder(fakeSWHID("cnt", 4), fakeSWHID("cnt", 15)) .setDirection(GraphDirection.BACKWARD).setDirectionReverse(GraphDirection.BACKWARD).build()); ArrayList actual = getSWHIDs(p); - SWHID expected = fakeSWHID("rev", 18); + SWHID expected = fakeSWHID("snp", 22); // FIXME: this changes any time to test dataset is regenerated Assertions.assertEquals(expected, actual.get(p.getMidpointIndex())); } diff --git a/java/src/test/java/org/softwareheritage/graph/rpc/FindPathToTest.java b/java/src/test/java/org/softwareheritage/graph/rpc/FindPathToTest.java --- a/java/src/test/java/org/softwareheritage/graph/rpc/FindPathToTest.java +++ b/java/src/test/java/org/softwareheritage/graph/rpc/FindPathToTest.java @@ -81,7 +81,7 @@ ArrayList actual = getSWHIDs(client.findPathTo( getRequestBuilder(fakeSWHID("dir", 16), "rel").setDirection(GraphDirection.BACKWARD).build())); List expected = List.of(fakeSWHID("dir", 16), fakeSWHID("dir", 17), fakeSWHID("rev", 18), - fakeSWHID("rel", 19)); + fakeSWHID("rel", 21)); // FIXME: rel:19 is valid too Assertions.assertEquals(expected, actual); } @@ -118,9 +118,13 @@ .addSrc(fakeSWHID("dir", 6).toString()).addSrc(fakeSWHID("dir", 8).toString()) .addSrc(fakeSWHID("dir", 12).toString()).addSrc(fakeSWHID("dir", 16).toString()) .addSrc(fakeSWHID("dir", 17).toString()).setDirection(GraphDirection.BACKWARD).build())); - List expected = List.of(fakeSWHID("dir", 8), fakeSWHID("rev", 9), fakeSWHID("snp", 20), + List expected1 = List.of(fakeSWHID("dir", 8), fakeSWHID("rev", 9), fakeSWHID("snp", 20), new SWHID(TEST_ORIGIN_ID)); - Assertions.assertEquals(expected, actual); + List expected2 = List.of(fakeSWHID("dir", 8), fakeSWHID("rev", 9), fakeSWHID("snp", 22), + new SWHID(TEST_ORIGIN_ID2)); + List> expected = List.of(expected1, expected2); + Assertions.assertTrue(expected.contains(actual), String.format("Expected either %s or %s, got %s", + expected1.toString(), expected2.toString(), actual.toString())); } // Impossible path between rev 9 and any release (forward graph) @@ -140,7 +144,7 @@ ArrayList actual = getSWHIDs(client.findPathTo(getRequestBuilder(fakeSWHID("cnt", 15), "rel") .setDirection(GraphDirection.BACKWARD).setMaxDepth(4).build())); List expected = List.of(fakeSWHID("cnt", 15), fakeSWHID("dir", 16), fakeSWHID("dir", 17), - fakeSWHID("rev", 18), fakeSWHID("rel", 19)); + fakeSWHID("rev", 18), fakeSWHID("rel", 21)); // FIXME: rel:19 is valid too Assertions.assertEquals(expected, actual); // Check that it throws NOT_FOUND with max depth = 1 @@ -154,15 +158,18 @@ // Path from cnt 15 to any rel with various max edges @Test public void maxEdges() { + int backtracked_edges = 2; // FIXME: Number of edges traversed but backtracked from. it changes + // nondeterministically every time the test dataset is changed. + ArrayList actual = getSWHIDs(client.findPathTo(getRequestBuilder(fakeSWHID("cnt", 15), "rel") - .setDirection(GraphDirection.BACKWARD).setMaxEdges(4).build())); + .setDirection(GraphDirection.BACKWARD).setMaxEdges(4 + backtracked_edges).build())); List expected = List.of(fakeSWHID("cnt", 15), fakeSWHID("dir", 16), fakeSWHID("dir", 17), - fakeSWHID("rev", 18), fakeSWHID("rel", 19)); + fakeSWHID("rev", 18), fakeSWHID("rel", 21)); // FIXME: rel:19 is valid too Assertions.assertEquals(expected, actual); StatusRuntimeException thrown = Assertions.assertThrows(StatusRuntimeException.class, () -> { client.findPathTo(getRequestBuilder(fakeSWHID("cnt", 15), "rel").setDirection(GraphDirection.BACKWARD) - .setMaxEdges(3).build()); + .setMaxEdges(3 + backtracked_edges).build()); }); Assertions.assertEquals(thrown.getStatus().getCode(), Status.NOT_FOUND.getCode()); } diff --git a/java/src/test/java/org/softwareheritage/graph/rpc/GetNodeTest.java b/java/src/test/java/org/softwareheritage/graph/rpc/GetNodeTest.java --- a/java/src/test/java/org/softwareheritage/graph/rpc/GetNodeTest.java +++ b/java/src/test/java/org/softwareheritage/graph/rpc/GetNodeTest.java @@ -17,6 +17,8 @@ import java.util.*; import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; public class GetNodeTest extends TraversalServiceTest { @Test @@ -110,9 +112,9 @@ } } - @Test - public void testReleases() { - List expectedRels = List.of(10, 19); + @ParameterizedTest + @ValueSource(ints = {10, 19}) + public void testReleases(Integer relId) { Map expectedMessages = Map.of(10, "Version 1.0", 19, "Version 2.0"); Map expectedNames = Map.of(10, "v1.0", 19, "v2.0"); @@ -122,36 +124,42 @@ Map expectedAuthorTimestampOffsets = Map.of(3, 120); HashMap personMapping = new HashMap<>(); - for (Integer relId : expectedRels) { - Node n = client.getNode(GetNodeRequest.newBuilder().setSwhid(fakeSWHID("rel", relId).toString()).build()); - assertTrue(n.hasRel()); - assertTrue(n.getRel().hasMessage()); - assertEquals(expectedMessages.get(relId), n.getRel().getMessage().toStringUtf8()); - // FIXME: names are always empty?! - // System.err.println(relId + " " + n.getRel().getName()); - // assertEquals(expectedNames.get(relId), n.getRel().getName().toStringUtf8()); - // Persons are anonymized, we just need to check that the mapping is self-consistent - assertTrue(n.getRel().hasAuthor()); - int actualPerson = (int) n.getRel().getAuthor(); - String expectedPerson = expectedAuthors.get(relId); - assertTrue(actualPerson >= 0); - if (personMapping.containsKey(actualPerson)) { - assertEquals(personMapping.get(actualPerson), expectedPerson); - } else { - personMapping.put(actualPerson, expectedPerson); - } + Node n = client.getNode(GetNodeRequest.newBuilder().setSwhid(fakeSWHID("rel", relId).toString()).build()); + assertTrue(n.hasRel()); + assertTrue(n.getRel().hasMessage()); + assertEquals(expectedMessages.get(relId), n.getRel().getMessage().toStringUtf8()); + // FIXME: names are always empty?! + // System.err.println(relId + " " + n.getRel().getName()); + // assertEquals(expectedNames.get(relId), n.getRel().getName().toStringUtf8()); + + // Persons are anonymized, we just need to check that the mapping is self-consistent + assertTrue(n.getRel().hasAuthor()); + int actualPerson = (int) n.getRel().getAuthor(); + String expectedPerson = expectedAuthors.get(relId); + assertTrue(actualPerson >= 0); + if (personMapping.containsKey(actualPerson)) { + assertEquals(personMapping.get(actualPerson), expectedPerson); + } else { + personMapping.put(actualPerson, expectedPerson); + } + if (relId == 10) { assertTrue(n.getRel().hasAuthorDate()); assertTrue(n.getRel().hasAuthorDateOffset()); + } else if (relId == 19) { + assertFalse(n.getRel().hasAuthorDate()); + assertFalse(n.getRel().hasAuthorDateOffset()); + } else { + assertTrue(false); + } - // FIXME: all the timestamps are one hour off?! - // if (expectedAuthorTimestamps.containsKey(relId)) { - // assertEquals(expectedAuthorTimestamps.get(revId), n.getRev().getAuthorDate()); - // } - if (expectedAuthorTimestampOffsets.containsKey(relId)) { - assertEquals(expectedAuthorTimestampOffsets.get(relId), n.getRev().getAuthorDateOffset()); - } + // FIXME: all the timestamps are one hour off?! + // if (expectedAuthorTimestamps.containsKey(relId)) { + // assertEquals(expectedAuthorTimestamps.get(revId), n.getRev().getAuthorDate()); + // } + if (expectedAuthorTimestampOffsets.containsKey(relId)) { + assertEquals(expectedAuthorTimestampOffsets.get(relId), n.getRev().getAuthorDateOffset()); } } @@ -235,18 +243,26 @@ } } - @Test - public void testRelMask() { + @ParameterizedTest + @ValueSource(ints = {10, 19}) + public void testRelMask(Integer relId) { Node n; - String swhid = fakeSWHID("rel", 19).toString(); + String swhid = fakeSWHID("rel", relId).toString(); // No mask, all fields present n = client.getNode(GetNodeRequest.newBuilder().setSwhid(swhid).build()); assertTrue(n.hasRel()); assertTrue(n.getRel().hasMessage()); assertTrue(n.getRel().hasAuthor()); - assertTrue(n.getRel().hasAuthorDate()); - assertTrue(n.getRel().hasAuthorDateOffset()); + if (relId == 10) { + assertTrue(n.getRel().hasAuthorDate()); + assertTrue(n.getRel().hasAuthorDateOffset()); + } else if (relId == 19) { + assertFalse(n.getRel().hasAuthorDate()); + assertFalse(n.getRel().hasAuthorDateOffset()); + } else { + assertTrue(false); + } // Empty mask, no fields present n = client.getNode(GetNodeRequest.newBuilder().setSwhid(swhid).setMask(FieldMask.getDefaultInstance()).build()); diff --git a/java/src/test/java/org/softwareheritage/graph/rpc/StatsTest.java b/java/src/test/java/org/softwareheritage/graph/rpc/StatsTest.java --- a/java/src/test/java/org/softwareheritage/graph/rpc/StatsTest.java +++ b/java/src/test/java/org/softwareheritage/graph/rpc/StatsTest.java @@ -15,10 +15,10 @@ @Test public void testStats() { StatsResponse stats = client.stats(StatsRequest.getDefaultInstance()); - assertEquals(stats.getNumNodes(), 21); - assertEquals(stats.getNumEdges(), 23); + assertEquals(stats.getNumNodes(), 24); + assertEquals(stats.getNumEdges(), 28); assertEquals(stats.getIndegreeMin(), 0); - assertEquals(stats.getIndegreeMax(), 3); + assertEquals(stats.getIndegreeMax(), 4); assertEquals(stats.getOutdegreeMin(), 0); assertEquals(stats.getOutdegreeMax(), 3); } diff --git a/java/src/test/java/org/softwareheritage/graph/rpc/TraverseLeavesTest.java b/java/src/test/java/org/softwareheritage/graph/rpc/TraverseLeavesTest.java --- a/java/src/test/java/org/softwareheritage/graph/rpc/TraverseLeavesTest.java +++ b/java/src/test/java/org/softwareheritage/graph/rpc/TraverseLeavesTest.java @@ -78,6 +78,7 @@ ArrayList actualLeaves1 = getSWHIDs(client.traverse(request1)); ArrayList expectedLeaves1 = new ArrayList<>(); expectedLeaves1.add(new SWHID("swh:1:rel:0000000000000000000000000000000000000019")); + expectedLeaves1.add(new SWHID(TEST_ORIGIN_ID2)); GraphTest.assertEqualsAnyOrder(expectedLeaves1, actualLeaves1); TraversalRequest request2 = getLeavesRequestBuilder(fakeSWHID("cnt", 4)).setDirection(GraphDirection.BACKWARD) @@ -85,6 +86,7 @@ ArrayList actualLeaves2 = getSWHIDs(client.traverse(request2)); ArrayList expectedLeaves2 = new ArrayList<>(); expectedLeaves2.add(new SWHID(TEST_ORIGIN_ID)); + expectedLeaves2.add(new SWHID(TEST_ORIGIN_ID2)); expectedLeaves2.add(new SWHID("swh:1:rel:0000000000000000000000000000000000000019")); GraphTest.assertEqualsAnyOrder(expectedLeaves2, actualLeaves2); } diff --git a/java/src/test/java/org/softwareheritage/graph/rpc/TraverseNeighborsTest.java b/java/src/test/java/org/softwareheritage/graph/rpc/TraverseNeighborsTest.java --- a/java/src/test/java/org/softwareheritage/graph/rpc/TraverseNeighborsTest.java +++ b/java/src/test/java/org/softwareheritage/graph/rpc/TraverseNeighborsTest.java @@ -112,6 +112,7 @@ ArrayList expectedNodes4 = new ArrayList<>(); expectedNodes4.add(new SWHID("swh:1:snp:0000000000000000000000000000000000000020")); expectedNodes4.add(new SWHID("swh:1:rel:0000000000000000000000000000000000000010")); + expectedNodes4.add(new SWHID("swh:1:snp:0000000000000000000000000000000000000022")); GraphTest.assertEqualsAnyOrder(expectedNodes4, actuals4); } @@ -132,6 +133,7 @@ expectedNodes2.add(new SWHID("swh:1:snp:0000000000000000000000000000000000000020")); expectedNodes2.add(new SWHID("swh:1:rel:0000000000000000000000000000000000000010")); expectedNodes2.add(new SWHID("swh:1:rev:0000000000000000000000000000000000000013")); + expectedNodes2.add(new SWHID("swh:1:snp:0000000000000000000000000000000000000022")); GraphTest.assertEqualsAnyOrder(expectedNodes2, actuals2); } } diff --git a/java/src/test/java/org/softwareheritage/graph/rpc/TraverseNodesTest.java b/java/src/test/java/org/softwareheritage/graph/rpc/TraverseNodesTest.java --- a/java/src/test/java/org/softwareheritage/graph/rpc/TraverseNodesTest.java +++ b/java/src/test/java/org/softwareheritage/graph/rpc/TraverseNodesTest.java @@ -97,7 +97,7 @@ ArrayList actual = getSWHIDs(client.traverse( getTraversalRequestBuilder(fakeSWHID("dir", 12)).setDirection(GraphDirection.BACKWARD).build())); List expected = List.of(fakeSWHID("dir", 12), fakeSWHID("rel", 19), fakeSWHID("rev", 13), - fakeSWHID("rev", 18)); + fakeSWHID("rev", 18), fakeSWHID("rel", 21), fakeSWHID("snp", 22), new SWHID(TEST_ORIGIN_ID2)); GraphTest.assertEqualsAnyOrder(expected, actual); } @@ -105,9 +105,10 @@ public void backwardFromLeaf() { ArrayList actual = getSWHIDs(client.traverse( getTraversalRequestBuilder(fakeSWHID("cnt", 4)).setDirection(GraphDirection.BACKWARD).build())); - List expected = List.of(new SWHID(TEST_ORIGIN_ID), fakeSWHID("cnt", 4), fakeSWHID("dir", 6), - fakeSWHID("dir", 8), fakeSWHID("dir", 12), fakeSWHID("rel", 10), fakeSWHID("rel", 19), - fakeSWHID("rev", 9), fakeSWHID("rev", 13), fakeSWHID("rev", 18), fakeSWHID("snp", 20)); + List expected = List.of(new SWHID(TEST_ORIGIN_ID), new SWHID(TEST_ORIGIN_ID2), fakeSWHID("cnt", 4), + fakeSWHID("dir", 6), fakeSWHID("dir", 8), fakeSWHID("dir", 12), fakeSWHID("rel", 10), + fakeSWHID("rel", 19), fakeSWHID("rev", 9), fakeSWHID("rev", 13), fakeSWHID("rev", 18), + fakeSWHID("snp", 20), fakeSWHID("rel", 21), fakeSWHID("snp", 22)); GraphTest.assertEqualsAnyOrder(expected, actual); } @@ -160,7 +161,7 @@ ArrayList actual = getSWHIDs(client.traverse(getTraversalRequestBuilder(fakeSWHID("rev", 3)) .setEdges("rev:rev,rev:rel").setDirection(GraphDirection.BACKWARD).build())); List expected = List.of(fakeSWHID("rel", 10), fakeSWHID("rel", 19), fakeSWHID("rev", 3), - fakeSWHID("rev", 9), fakeSWHID("rev", 13), fakeSWHID("rev", 18)); + fakeSWHID("rev", 9), fakeSWHID("rev", 13), fakeSWHID("rev", 18), fakeSWHID("rel", 21)); GraphTest.assertEqualsAnyOrder(expected, actual); } @@ -179,7 +180,8 @@ ArrayList actual = getSWHIDs(client.traverse(getTraversalRequestBuilder(fakeSWHID("rev", 3)) .setDirection(GraphDirection.BACKWARD).setEdges("rev:*").build())); List expected = List.of(fakeSWHID("rel", 10), fakeSWHID("rel", 19), fakeSWHID("rev", 3), - fakeSWHID("rev", 9), fakeSWHID("rev", 13), fakeSWHID("rev", 18), fakeSWHID("snp", 20)); + fakeSWHID("rev", 9), fakeSWHID("rev", 13), fakeSWHID("rev", 18), fakeSWHID("snp", 20), + fakeSWHID("rel", 21), fakeSWHID("snp", 22)); GraphTest.assertEqualsAnyOrder(expected, actual); } @@ -244,14 +246,12 @@ GraphTest.assertEqualsAnyOrder(expected, actual); actual = getSWHIDs(client.traverse(builder.setMaxEdges(7).build())); - expected = List.of(fakeSWHID("rel", 19), fakeSWHID("rev", 18), fakeSWHID("rev", 13), fakeSWHID("dir", 17), - fakeSWHID("cnt", 14)); + expected = List.of(fakeSWHID("rel", 19), fakeSWHID("rev", 18), fakeSWHID("rev", 13), fakeSWHID("dir", 17)); GraphTest.assertEqualsAnyOrder(expected, actual); actual = getSWHIDs(client.traverse(builder.setMaxEdges(12).build())); expected = List.of(fakeSWHID("rel", 19), fakeSWHID("rev", 18), fakeSWHID("rev", 13), fakeSWHID("dir", 17), - fakeSWHID("rev", 9), fakeSWHID("dir", 12), fakeSWHID("dir", 16), fakeSWHID("cnt", 14), - fakeSWHID("cnt", 15)); + fakeSWHID("rev", 9), fakeSWHID("dir", 12), fakeSWHID("dir", 16), fakeSWHID("cnt", 14)); GraphTest.assertEqualsAnyOrder(expected, actual); } }