public void testAddVertexProperties(final Graph graph) { if (!config.isRDFModel) { List<String> ids = generateIds(3); Vertex v1 = graph.addVertex(convertId(ids.get(0))); Vertex v2 = graph.addVertex(convertId(ids.get(1))); v1.setProperty("key1", "value1"); v1.setProperty("key2", 10); v2.setProperty("key2", 20); assertEquals("value1", v1.getProperty("key1")); assertEquals(10, v1.getProperty("key2")); assertEquals(20, v2.getProperty("key2")); } else { Vertex v1 = graph.addVertex("\"1\"^^<http://www.w3.org/2001/XMLSchema#int>"); assertEquals("http://www.w3.org/2001/XMLSchema#int", v1.getProperty(SailTokens.DATATYPE)); assertEquals(1, v1.getProperty(SailTokens.VALUE)); assertNull(v1.getProperty(SailTokens.LANGUAGE)); assertNull(v1.getProperty("random something")); Vertex v2 = graph.addVertex("\"hello\"@en"); assertEquals("en", v2.getProperty(SailTokens.LANGUAGE)); assertEquals("hello", v2.getProperty(SailTokens.VALUE)); assertNull(v2.getProperty(SailTokens.DATATYPE)); assertNull(v2.getProperty("random something")); } }
public void testSemanticallyCorrectIterables() { Graph graph = graphTest.generateGraph(); for (int i = 0; i < 15; i++) { graph.addEdge(null, graph.addVertex(null), graph.addVertex(null), convertId(graph, "knows")); } if (graph.getFeatures().supportsVertexIteration) { Iterable<Vertex> vertices = graph.getVertices(); assertEquals(count(vertices), 30); assertEquals(count(vertices), 30); Iterator<Vertex> itty = vertices.iterator(); int counter = 0; while (itty.hasNext()) { assertTrue(itty.hasNext()); itty.next(); counter++; } assertEquals(counter, 30); } if (graph.getFeatures().supportsEdgeIteration) { Iterable<Edge> edges = graph.getEdges(); assertEquals(count(edges), 15); assertEquals(count(edges), 15); Iterator<Edge> itty = edges.iterator(); int counter = 0; while (itty.hasNext()) { assertTrue(itty.hasNext()); itty.next(); counter++; } assertEquals(counter, 15); } graph.shutdown(); }
public void testAddingSelfLoops() { Graph graph = graphTest.getGraphInstance(); if (graphTest.allowsSelfLoops) { List<String> ids = generateIds(3); Vertex v1 = graph.addVertex(convertId(ids.get(0))); Vertex v2 = graph.addVertex(convertId(ids.get(1))); Vertex v3 = graph.addVertex(convertId(ids.get(2))); graph.addEdge(null, v1, v1, convertId("is_self")); graph.addEdge(null, v2, v2, convertId("is_self")); graph.addEdge(null, v3, v3, convertId("is_self")); if (graphTest.supportsVertexIteration) assertEquals(3, count(graph.getVertices())); if (graphTest.supportsEdgeIteration) { assertEquals(3, count(graph.getEdges())); int counter = 0; for (Edge edge : graph.getEdges()) { counter++; assertEquals(edge.getInVertex(), edge.getOutVertex()); assertEquals(edge.getInVertex().getId(), edge.getOutVertex().getId()); } assertEquals(counter, 3); } } graph.shutdown(); }
public void testAddingDuplicateEdges() { Graph graph = graphTest.generateGraph(); Vertex v1 = graph.addVertex(convertId(graph, "1")); Vertex v2 = graph.addVertex(convertId(graph, "2")); Vertex v3 = graph.addVertex(convertId(graph, "3")); graph.addEdge(null, v1, v2, convertId(graph, "knows")); graph.addEdge(null, v2, v3, convertId(graph, "pets")); graph.addEdge(null, v2, v3, convertId(graph, "pets")); graph.addEdge(null, v2, v3, convertId(graph, "pets")); graph.addEdge(null, v2, v3, convertId(graph, "pets")); if (graph.getFeatures().supportsDuplicateEdges) { if (graph.getFeatures().supportsVertexIteration) assertEquals(3, count(graph.getVertices())); if (graph.getFeatures().supportsEdgeIteration) assertEquals(5, count(graph.getEdges())); assertEquals(0, count(v1.getEdges(Direction.IN))); assertEquals(1, count(v1.getEdges(Direction.OUT))); assertEquals(1, count(v2.getEdges(Direction.IN))); assertEquals(4, count(v2.getEdges(Direction.OUT))); assertEquals(4, count(v3.getEdges(Direction.IN))); assertEquals(0, count(v3.getEdges(Direction.OUT))); } else { if (graph.getFeatures().supportsVertexIteration) assertEquals(count(graph.getVertices()), 3); if (graph.getFeatures().supportsEdgeIteration) assertEquals(count(graph.getEdges()), 2); assertEquals(0, count(v1.getEdges(Direction.IN))); assertEquals(1, count(v1.getEdges(Direction.OUT))); assertEquals(1, count(v2.getEdges(Direction.IN))); assertEquals(1, count(v2.getEdges(Direction.OUT))); assertEquals(1, count(v3.getEdges(Direction.IN))); assertEquals(0, count(v3.getEdges(Direction.OUT))); } graph.shutdown(); }
public void testConcurrentModification() { Graph graph = graphTest.generateGraph(); Vertex a = graph.addVertex(null); graph.addVertex(null); graph.addVertex(null); if (graph.getFeatures().supportsVertexIteration) { for (Vertex vertex : graph.getVertices()) { graph.addEdge(null, vertex, a, convertId(graph, "x")); graph.addEdge(null, vertex, a, convertId(graph, "y")); } for (Vertex vertex : graph.getVertices()) { assertEquals(BaseTest.count(vertex.getEdges(Direction.OUT)), 2); for (Edge edge : vertex.getEdges(Direction.OUT)) { graph.removeEdge(edge); } } for (Vertex vertex : graph.getVertices()) { graph.removeVertex(vertex); } } else if (graph.getFeatures().supportsEdgeIteration) { for (int i = 0; i < 10; i++) { graph.addEdge(null, graph.addVertex(null), graph.addVertex(null), convertId(graph, "test")); } for (Edge edge : graph.getEdges()) { graph.removeEdge(edge); } } graph.shutdown(); }
@Test public void testDetectCycles5() { Graph g = new Graph(); Vertex v1 = new VertexTest(1); Vertex v2 = new VertexTest(2); Vertex v3 = new VertexTest(3); Vertex v4 = new VertexTest(4); Edge e1 = new Edge(v1, v2); Edge e2 = new Edge(v2, v3); Edge e3 = new Edge(v3, v1); Edge e4 = new Edge(v1, v4); Edge e5 = new Edge(v4, v3); g.addVertex(v2); g.addVertex(v4); g.addVertex(v3); g.addVertex(v1); g.addEdge(e2); g.addEdge(e1); g.addEdge(e3); g.addEdge(e2); g.addEdge(e1); g.addEdge(e3); g.addEdge(e5); g.addEdge(e4); assertTrue(g.getAllEdgesInDirectedCycles().size() == 5); }
public void testVertexEquality(final Graph graph) { List<String> ids = generateIds(1); if (!config.ignoresSuppliedIds) { Vertex v = graph.addVertex(convertId(ids.get(0))); Vertex u = graph.getVertex(convertId(ids.get(0))); assertEquals(v, u); } this.stopWatch(); Vertex v = graph.addVertex(null); Vertex u = graph.getVertex(v.getId()); BaseTest.printPerformance(graph.toString(), 1, "vertex added and retrieved", this.stopWatch()); assertEquals(v, u); assertEquals(graph.getVertex(u.getId()), graph.getVertex(u.getId())); assertEquals(graph.getVertex(v.getId()), graph.getVertex(u.getId())); assertEquals(graph.getVertex(v.getId()), graph.getVertex(v.getId())); graph.clear(); if (!config.ignoresSuppliedIds) { v = graph.addVertex(convertId(ids.get(0))); u = graph.getVertex(convertId(ids.get(0))); Set<Vertex> set = new HashSet<Vertex>(); set.add(v); set.add(v); set.add(u); set.add(u); set.add(graph.getVertex(convertId(ids.get(0)))); set.add(graph.getVertex(convertId(ids.get(0)))); if (config.supportsVertexIndex) set.add(graph.getVertices().iterator().next()); assertEquals(1, set.size()); } }
protected Graph<String, DefaultWeightedEdge> createWithBias(boolean negate) { Graph<String, DefaultWeightedEdge> g; double bias = 1; if (negate) { // negative-weight edges are being tested, so only a directed graph // makes sense g = new SimpleDirectedWeightedGraph<String, DefaultWeightedEdge>(DefaultWeightedEdge.class); bias = -1; } else { // by default, use an undirected graph g = new SimpleWeightedGraph<String, DefaultWeightedEdge>(DefaultWeightedEdge.class); } g.addVertex(V1); g.addVertex(V2); g.addVertex(V3); g.addVertex(V4); g.addVertex(V5); e12 = Graphs.addEdge(g, V1, V2, bias * 2); e13 = Graphs.addEdge(g, V1, V3, bias * 3); e24 = Graphs.addEdge(g, V2, V4, bias * 5); e34 = Graphs.addEdge(g, V3, V4, bias * 20); e45 = Graphs.addEdge(g, V4, V5, bias * 5); e15 = Graphs.addEdge(g, V1, V5, bias * 100); return g; }
public void testGetEdges() { Graph graph = graphTest.getGraphInstance(); if (!graphTest.isRDFModel) { Vertex v1 = graph.addVertex(null); Vertex v2 = graph.addVertex(null); Vertex v3 = graph.addVertex(null); Edge e1 = graph.addEdge(null, v1, v2, "test1"); Edge e2 = graph.addEdge(null, v2, v3, "test2"); Edge e3 = graph.addEdge(null, v3, v1, "test3"); this.stopWatch(); assertEquals(graph.getEdge(e1.getId()), e1); assertEquals(graph.getEdge(e1.getId()).getInVertex(), v2); assertEquals(graph.getEdge(e1.getId()).getOutVertex(), v1); assertEquals(graph.getEdge(e2.getId()), e2); assertEquals(graph.getEdge(e2.getId()).getInVertex(), v3); assertEquals(graph.getEdge(e2.getId()).getOutVertex(), v2); assertEquals(graph.getEdge(e3.getId()), e3); assertEquals(graph.getEdge(e3.getId()).getInVertex(), v1); assertEquals(graph.getEdge(e3.getId()).getOutVertex(), v3); BaseTest.printPerformance(graph.toString(), 3, "edges retrieved", this.stopWatch()); } graph.shutdown(); }
public void testRemoveManyEdges() { Graph graph = graphTest.getGraphInstance(); long counter = 200000l; int edgeCount = 100; Set<Edge> edges = new HashSet<Edge>(); for (int i = 0; i < edgeCount; i++) { Vertex out = graph.addVertex(convertId("" + counter++)); Vertex in = graph.addVertex(convertId("" + counter++)); edges.add(graph.addEdge(null, out, in, convertId("a" + UUID.randomUUID().toString()))); } assertEquals(edgeCount, edges.size()); if (graphTest.supportsVertexIteration) { this.stopWatch(); assertEquals(edgeCount * 2, count(graph.getVertices())); BaseTest.printPerformance( graph.toString(), edgeCount * 2, "vertices counted", this.stopWatch()); } if (graphTest.supportsEdgeIteration) { this.stopWatch(); assertEquals(edgeCount, count(graph.getEdges())); BaseTest.printPerformance(graph.toString(), edgeCount, "edges counted", this.stopWatch()); int i = edgeCount; this.stopWatch(); for (Edge edge : edges) { graph.removeEdge(edge); i--; assertEquals(i, count(graph.getEdges())); if (graphTest.supportsVertexIteration) { int x = 0; for (Vertex vertex : graph.getVertices()) { if (count(vertex.getOutEdges()) > 0) { assertEquals(1, count(vertex.getOutEdges())); assertFalse(count(vertex.getInEdges()) > 0); } else if (count(vertex.getInEdges()) > 0) { assertEquals(1, count(vertex.getInEdges())); assertFalse(count(vertex.getOutEdges()) > 0); } else { x++; } } assertEquals((edgeCount - i) * 2, x); } } BaseTest.printPerformance( graph.toString(), edgeCount, "edges removed and graph checked", this.stopWatch()); } graph.shutdown(); }
public void testAddManyVertexProperties(final Graph graph) { if (!config.isRDFModel) { Set<Vertex> vertices = new HashSet<Vertex>(); this.stopWatch(); for (int i = 0; i < 50; i++) { Vertex vertex = graph.addVertex(null); for (int j = 0; j < 15; j++) { vertex.setProperty(UUID.randomUUID().toString(), UUID.randomUUID().toString()); } vertices.add(vertex); } BaseTest.printPerformance( graph.toString(), 15 * 50, "vertex properties added (with vertices being added too)", this.stopWatch()); if (config.supportsVertexIteration) assertEquals(50, count(graph.getVertices())); assertEquals(50, vertices.size()); for (Vertex vertex : vertices) { assertEquals(15, vertex.getPropertyKeys().size()); } } else { Set<Vertex> vertices = new HashSet<Vertex>(); this.stopWatch(); for (int i = 0; i < 50; i++) { Vertex vertex = graph.addVertex("\"" + UUID.randomUUID().toString() + "\""); for (int j = 0; j < 15; j++) { vertex.setProperty(SailTokens.DATATYPE, "http://www.w3.org/2001/XMLSchema#anyURI"); } vertices.add(vertex); } BaseTest.printPerformance( graph.toString(), 15 * 50, "vertex properties added (with vertices being added too)", this.stopWatch()); if (config.supportsVertexIteration) assertEquals(count(graph.getVertices()), 50); assertEquals(vertices.size(), 50); for (Vertex vertex : vertices) { assertEquals(2, vertex.getPropertyKeys().size()); assertTrue(vertex.getPropertyKeys().contains(SailTokens.DATATYPE)); assertEquals( "http://www.w3.org/2001/XMLSchema#anyURI", vertex.getProperty(SailTokens.DATATYPE)); assertTrue(vertex.getPropertyKeys().contains(SailTokens.VALUE)); } } }
public void testAddingRemovingEdgeProperties() { Graph graph = graphTest.generateGraph(); if (graph.getFeatures().supportsEdgeProperties) { Vertex a = graph.addVertex(convertId(graph, "1")); Vertex b = graph.addVertex(convertId(graph, "2")); Edge edge = graph.addEdge(convertId(graph, "3"), a, b, "knows"); assertEquals(edge.getPropertyKeys().size(), 0); assertNull(edge.getProperty("weight")); if (graph.getFeatures().supportsDoubleProperty) { edge.setProperty("weight", 0.5); assertEquals(edge.getPropertyKeys().size(), 1); assertEquals(edge.getProperty("weight"), 0.5); edge.setProperty("weight", 0.6); assertEquals(edge.getPropertyKeys().size(), 1); assertEquals(edge.getProperty("weight"), 0.6); assertEquals(edge.removeProperty("weight"), 0.6); assertNull(edge.getProperty("weight")); assertEquals(edge.getPropertyKeys().size(), 0); } if (graph.getFeatures().supportsStringProperty) { edge.setProperty("blah", "marko"); edge.setProperty("blah2", "josh"); assertEquals(edge.getPropertyKeys().size(), 2); } } graph.shutdown(); }
@Test public void testDetectCycles2() { Graph g = new Graph(); Vertex v1 = new Vertex(); Vertex v2 = new Vertex(); Vertex v3 = new Vertex(); Edge e1 = new Edge(v1, v2); Edge e2 = new Edge(v2, v3); g.addVertex(v3); g.addVertex(v1); g.addVertex(v2); g.addEdge(e2); g.addEdge(e1); if (!g.getAllEdgesInDirectedCycles().isEmpty()) fail("bad cycles :("); }
public void testAddingVerticesAndEdges() { Graph graph = graphTest.generateGraph(); Vertex a = graph.addVertex(null); Vertex b = graph.addVertex(null); Edge edge = graph.addEdge(null, a, b, convertId(graph, "knows")); if (graph.getFeatures().supportsEdgeIteration) { assertEquals(1, count(graph.getEdges())); } if (graph.getFeatures().supportsVertexIteration) { assertEquals(2, count(graph.getVertices())); } graph.removeVertex(a); if (graph.getFeatures().supportsEdgeIteration) { assertEquals(0, count(graph.getEdges())); } if (graph.getFeatures().supportsVertexIteration) { assertEquals(1, count(graph.getVertices())); } try { graph.removeEdge(edge); // TODO: doesn't work with wrapper graphs assertTrue(false); } catch (Exception e) { assertTrue(true); } if (graph.getFeatures().supportsEdgeIteration) { assertEquals(0, count(graph.getEdges())); } if (graph.getFeatures().supportsVertexIteration) { assertEquals(1, count(graph.getVertices())); } graph.shutdown(); }
/** * Generates AdjacencyListGraph based on the values in the input file. * * @requires twitterStream is properly initialized * @param twitterStream initialized input stream for reading twitter file * @return generated graph based on input file */ private static Graph readTwitterFile(FileInputStream twitterStream) { final int U1_INDEX = 0; final int U2_INDEX = 1; try { Graph g = new AdjacencyListGraph(); BufferedReader twitterReader = new BufferedReader(new InputStreamReader(twitterStream)); String line; while ((line = twitterReader.readLine()) != null) { // eliminate any unnecessary whitespace String[] columns = line.trim().replaceAll("\\s+", "").split("->"); // first column is user 1 // second column is user 2 Vertex u1 = new Vertex(columns[U1_INDEX]); Vertex u2 = new Vertex(columns[U2_INDEX]); // System.out.println(columns[0]+","+columns[1]); g.addVertex(u1); g.addVertex(u2); g.addEdge(u1, u2); // System.out.println(line); } twitterReader.close(); return g; } catch (Exception e) { // if something somehow goes wrong throw new RuntimeException(e); } }
/** * the addVertexes() method adds all vertexes read from the node shapefile into a graph * * @throws Exception */ @SuppressWarnings("rawtypes") public void addVertexes() throws Exception { Iterator it = shapeFileNodes.entrySet().iterator(); while (it.hasNext()) { Map.Entry pair = (Map.Entry) it.next(); graph.addVertex((Vertex) pair.getValue(), true); } }
@Test public void testWeakComponent2() { VertexTest added = new VertexTest(5); tested.addVertex(added); EdgeTest addEdge = new EdgeTest(added, tested.getVertices().get(1)); tested.addEdge(addEdge); if (tested.getAllWeakClosureComponent().size() != 2) fail("weak component :("); }
public void testEmptyKeyProperty() { final Graph graph = graphTest.generateGraph(); // no point in testing graph features for setting string properties because the intent is for it // to // fail based on the empty key. if (graph.getFeatures().supportsEdgeProperties) { final Edge e = graph.addEdge(null, graph.addVertex(null), graph.addVertex(null), "friend"); try { e.setProperty("", "value"); fail(); } catch (IllegalArgumentException e1) { assertTrue(true); } } graph.shutdown(); }
public void testRemoveSelfLoops() { Graph graph = graphTest.getGraphInstance(); if (graphTest.allowsSelfLoops) { List<String> ids = generateIds(3); Vertex v1 = graph.addVertex(convertId(ids.get(0))); Vertex v2 = graph.addVertex(convertId(ids.get(1))); Vertex v3 = graph.addVertex(convertId(ids.get(2))); Edge e1 = graph.addEdge(null, v1, v1, convertId("is_self")); Edge e2 = graph.addEdge(null, v2, v2, convertId("is_self")); Edge e3 = graph.addEdge(null, v3, v3, convertId("is_self")); if (graphTest.supportsVertexIteration) assertEquals(3, count(graph.getVertices())); if (graphTest.supportsEdgeIteration) { assertEquals(3, count(graph.getEdges())); for (Edge edge : graph.getEdges()) { assertEquals(edge.getInVertex(), edge.getOutVertex()); assertEquals(edge.getInVertex().getId(), edge.getOutVertex().getId()); } } graph.removeVertex(v1); if (graphTest.supportsEdgeIteration) { assertEquals(2, count(graph.getEdges())); for (Edge edge : graph.getEdges()) { assertEquals(edge.getInVertex(), edge.getOutVertex()); assertEquals(edge.getInVertex().getId(), edge.getOutVertex().getId()); } } assertEquals(1, count(v2.getOutEdges())); assertEquals(1, count(v2.getInEdges())); graph.removeEdge(e2); assertEquals(0, count(v2.getOutEdges())); assertEquals(0, count(v2.getInEdges())); if (graphTest.supportsEdgeIteration) { assertEquals(count(graph.getEdges()), 1); for (Edge edge : graph.getEdges()) { assertEquals(edge.getInVertex(), edge.getOutVertex()); assertEquals(edge.getInVertex().getId(), edge.getOutVertex().getId()); } } } graph.shutdown(); }
public void testRemoveEdgesByRemovingVertex() { Graph graph = graphTest.generateGraph(); Vertex v1 = graph.addVertex(convertId(graph, "1")); Vertex v2 = graph.addVertex(convertId(graph, "2")); Vertex v3 = graph.addVertex(convertId(graph, "3")); graph.addEdge(null, v1, v2, convertId(graph, "knows")); graph.addEdge(null, v2, v3, convertId(graph, "pets")); graph.addEdge(null, v2, v3, convertId(graph, "pets")); assertEquals(0, count(v1.getEdges(Direction.IN))); assertEquals(1, count(v1.getEdges(Direction.OUT))); assertEquals(1, count(v2.getEdges(Direction.IN))); assertEquals(0, count(v3.getEdges(Direction.OUT))); if (!graph.getFeatures().ignoresSuppliedIds) { v1 = graph.getVertex(convertId(graph, "1")); v2 = graph.getVertex(convertId(graph, "2")); v3 = graph.getVertex(convertId(graph, "3")); assertEquals(0, count(v1.getEdges(Direction.IN))); assertEquals(1, count(v1.getEdges(Direction.OUT))); assertEquals(1, count(v2.getEdges(Direction.IN))); assertEquals(0, count(v3.getEdges(Direction.OUT))); } if (graph.getFeatures().supportsVertexIteration) assertEquals(3, count(graph.getVertices())); graph.removeVertex(v1); if (graph.getFeatures().supportsVertexIteration) assertEquals(2, count(graph.getVertices())); if (graph.getFeatures().supportsDuplicateEdges) assertEquals(2, count(v2.getEdges(Direction.OUT))); else assertEquals(1, count(v2.getEdges(Direction.OUT))); assertEquals(0, count(v3.getEdges(Direction.OUT))); assertEquals(0, count(v2.getEdges(Direction.IN))); if (graph.getFeatures().supportsDuplicateEdges) assertEquals(2, count(v3.getEdges(Direction.IN))); else assertEquals(1, count(v3.getEdges(Direction.IN))); graph.shutdown(); }
public void testRemoveVertex(final Graph graph) { List<String> ids = generateIds(1); Vertex v1 = graph.addVertex(convertId(ids.get(0))); if (config.supportsVertexIteration) assertEquals(1, count(graph.getVertices())); graph.removeVertex(v1); if (config.supportsVertexIteration) assertEquals(0, count(graph.getVertices())); Set<Vertex> vertices = new HashSet<Vertex>(); for (int i = 0; i < 1000; i++) { vertices.add(graph.addVertex(null)); } if (config.supportsVertexIteration) assertEquals(1000, count(graph.getVertices())); for (Vertex v : vertices) { graph.removeVertex(v); } if (config.supportsVertexIteration) assertEquals(0, count(graph.getVertices())); }
public void testNoConcurrentModificationException() { Graph graph = graphTest.generateGraph(); for (int i = 0; i < 25; i++) { graph.addEdge(null, graph.addVertex(null), graph.addVertex(null), convertId(graph, "test")); } if (graph.getFeatures().supportsVertexIteration) assertEquals(BaseTest.count(graph.getVertices()), 50); if (graph.getFeatures().supportsEdgeIteration) { assertEquals(BaseTest.count(graph.getEdges()), 25); for (final Edge edge : graph.getEdges()) { graph.removeEdge(edge); } assertEquals(BaseTest.count(graph.getEdges()), 0); } if (graph.getFeatures().supportsVertexIteration) assertEquals(BaseTest.count(graph.getVertices()), 50); graph.shutdown(); }
public void testRemoveSelfLoops() { Graph graph = graphTest.generateGraph(); if (graph.getFeatures().supportsSelfLoops) { Vertex v1 = graph.addVertex(convertId(graph, "1")); Vertex v2 = graph.addVertex(convertId(graph, "2")); Vertex v3 = graph.addVertex(convertId(graph, "3")); Edge e1 = graph.addEdge(null, v1, v1, convertId(graph, "is_self")); Edge e2 = graph.addEdge(null, v2, v2, convertId(graph, "is_self")); Edge e3 = graph.addEdge(null, v3, v3, convertId(graph, "is_self")); if (graph.getFeatures().supportsVertexIteration) assertEquals(3, count(graph.getVertices())); if (graph.getFeatures().supportsEdgeIteration) { assertEquals(3, count(graph.getEdges())); for (Edge edge : graph.getEdges()) { assertEquals(edge.getVertex(Direction.IN), edge.getVertex(Direction.OUT)); assertEquals(edge.getVertex(Direction.IN).getId(), edge.getVertex(Direction.OUT).getId()); } } graph.removeVertex(v1); if (graph.getFeatures().supportsEdgeIteration) { assertEquals(2, count(graph.getEdges())); for (Edge edge : graph.getEdges()) { assertEquals(edge.getVertex(Direction.IN), edge.getVertex(Direction.OUT)); assertEquals(edge.getVertex(Direction.IN).getId(), edge.getVertex(Direction.OUT).getId()); } } assertEquals(1, count(v2.getEdges(Direction.OUT))); assertEquals(1, count(v2.getEdges(Direction.IN))); graph.removeEdge(e2); assertEquals(0, count(v2.getEdges(Direction.OUT))); assertEquals(0, count(v2.getEdges(Direction.IN))); if (graph.getFeatures().supportsEdgeIteration) { assertEquals(count(graph.getEdges()), 1); for (Edge edge : graph.getEdges()) { assertEquals(edge.getVertex(Direction.IN), edge.getVertex(Direction.OUT)); assertEquals(edge.getVertex(Direction.IN).getId(), edge.getVertex(Direction.OUT).getId()); } } } graph.shutdown(); }
public void testRemoveEdgesByRemovingVertex() { Graph graph = graphTest.getGraphInstance(); List<String> ids = generateIds(3); Vertex v1 = graph.addVertex(convertId(ids.get(0))); Vertex v2 = graph.addVertex(convertId(ids.get(1))); Vertex v3 = graph.addVertex(convertId(ids.get(2))); graph.addEdge(null, v1, v2, convertId("knows")); graph.addEdge(null, v2, v3, convertId("pets")); graph.addEdge(null, v2, v3, convertId("pets")); assertEquals(0, count(v1.getInEdges())); assertEquals(1, count(v1.getOutEdges())); assertEquals(1, count(v2.getInEdges())); assertEquals(0, count(v3.getOutEdges())); if (!graphTest.ignoresSuppliedIds) { v1 = graph.getVertex(convertId(ids.get(0))); v2 = graph.getVertex(convertId(ids.get(1))); v3 = graph.getVertex(convertId(ids.get(2))); assertEquals(0, count(v1.getInEdges())); assertEquals(1, count(v1.getOutEdges())); assertEquals(1, count(v2.getInEdges())); assertEquals(0, count(v3.getOutEdges())); } if (graphTest.supportsVertexIteration) assertEquals(3, count(graph.getVertices())); graph.removeVertex(v1); if (graphTest.supportsVertexIteration) assertEquals(2, count(graph.getVertices())); if (graphTest.allowsDuplicateEdges) assertEquals(2, count(v2.getOutEdges())); else assertEquals(1, count(v2.getOutEdges())); assertEquals(0, count(v3.getOutEdges())); assertEquals(0, count(v2.getInEdges())); if (graphTest.allowsDuplicateEdges) assertEquals(2, count(v3.getInEdges())); else assertEquals(1, count(v3.getInEdges())); graph.shutdown(); }
public void testVertexEdgeLabels() { Graph graph = graphTest.generateGraph(); Vertex a = graph.addVertex(null); Vertex b = graph.addVertex(null); Vertex c = graph.addVertex(null); Edge aFriendB = graph.addEdge(null, a, b, convertId(graph, "friend")); Edge aFriendC = graph.addEdge(null, a, c, convertId(graph, "friend")); Edge aHateC = graph.addEdge(null, a, c, convertId(graph, "hate")); Edge cHateA = graph.addEdge(null, c, a, convertId(graph, "hate")); Edge cHateB = graph.addEdge(null, c, b, convertId(graph, "hate")); List<Edge> results = asList(a.getEdges(Direction.OUT)); assertEquals(results.size(), 3); assertTrue(results.contains(aFriendB)); assertTrue(results.contains(aFriendC)); assertTrue(results.contains(aHateC)); results = asList(a.getEdges(Direction.OUT, convertId(graph, "friend"))); assertEquals(results.size(), 2); assertTrue(results.contains(aFriendB)); assertTrue(results.contains(aFriendC)); results = asList(a.getEdges(Direction.OUT, convertId(graph, "hate"))); assertEquals(results.size(), 1); assertTrue(results.contains(aHateC)); results = asList(a.getEdges(Direction.IN, convertId(graph, "hate"))); assertEquals(results.size(), 1); assertTrue(results.contains(cHateA)); results = asList(a.getEdges(Direction.IN, convertId(graph, "friend"))); assertEquals(results.size(), 0); results = asList(b.getEdges(Direction.IN, convertId(graph, "hate"))); assertEquals(results.size(), 1); assertTrue(results.contains(cHateB)); results = asList(b.getEdges(Direction.IN, convertId(graph, "friend"))); assertEquals(results.size(), 1); assertTrue(results.contains(aFriendB)); graph.shutdown(); }
public void testAddEdges() { Graph graph = graphTest.generateGraph(); this.stopWatch(); Vertex v1 = graph.addVertex(convertId(graph, "1")); Vertex v2 = graph.addVertex(convertId(graph, "2")); Vertex v3 = graph.addVertex(convertId(graph, "3")); graph.addEdge(null, v1, v2, convertId(graph, "knows")); graph.addEdge(null, v2, v3, convertId(graph, "pets")); graph.addEdge(null, v2, v3, convertId(graph, "caresFor")); assertEquals(1, count(v1.getEdges(Direction.OUT))); assertEquals(2, count(v2.getEdges(Direction.OUT))); assertEquals(0, count(v3.getEdges(Direction.OUT))); assertEquals(0, count(v1.getEdges(Direction.IN))); assertEquals(1, count(v2.getEdges(Direction.IN))); assertEquals(2, count(v3.getEdges(Direction.IN))); printPerformance(graph.toString(), 6, "elements added and checked", this.stopWatch()); graph.shutdown(); }
public static void main(String[] args) { Graph<Integer> graf1 = new AdjacencyListUndirectedGraph<Integer>(); graf1.addVertex(1); graf1.addVertex(2); graf1.addVertex(3); graf1.addVertex(4); graf1.addVertex(5); graf1.addEdge(1, 2, 2); graf1.addEdge(1, 3, 1); graf1.addEdge(3, 4, 1); graf1.addEdge(3, 5, 4); graf1.addEdge(2, 4, 2); graf1.addEdge(4, 5, 1); DijkstraShortestPath<Integer> path1 = new DijkstraShortestPath<Integer>(graf1); path1.searchShortestPath(1, 5); System.out.println(path1.getDistance()); System.out.println(path1.getShortestPath()); }
public void testEdgeIterator() { Graph graph = graphTest.getGraphInstance(); if (graphTest.supportsEdgeIteration) { List<String> ids = generateIds(3); Vertex v1 = graph.addVertex(convertId(ids.get(0))); Vertex v2 = graph.addVertex(convertId(ids.get(1))); Vertex v3 = graph.addVertex(convertId(ids.get(2))); Edge e1 = graph.addEdge(null, v1, v2, convertId("test")); Edge e2 = graph.addEdge(null, v2, v3, convertId("test")); Edge e3 = graph.addEdge(null, v3, v1, convertId("test")); if (graphTest.supportsVertexIteration) assertEquals(3, count(graph.getVertices())); if (graphTest.supportsEdgeIteration) assertEquals(3, count(graph.getEdges())); Set<String> edgeIds = new HashSet<String>(); int count = 0; for (Edge e : graph.getEdges()) { count++; edgeIds.add(e.getId().toString()); assertEquals(convertId("test"), e.getLabel()); if (e.getId().toString().equals(e1.getId().toString())) { assertEquals(v1, e.getOutVertex()); assertEquals(v2, e.getInVertex()); } else if (e.getId().toString().equals(e2.getId().toString())) { assertEquals(v2, e.getOutVertex()); assertEquals(v3, e.getInVertex()); } else if (e.getId().toString().equals(e3.getId().toString())) { assertEquals(v3, e.getOutVertex()); assertEquals(v1, e.getInVertex()); } else { assertTrue(false); } // System.out.println(e); } assertEquals(3, count); assertEquals(3, edgeIds.size()); assertTrue(edgeIds.contains(e1.getId().toString())); assertTrue(edgeIds.contains(e2.getId().toString())); assertTrue(edgeIds.contains(e3.getId().toString())); } graph.shutdown(); }
public void testAddEdges() { Graph graph = graphTest.getGraphInstance(); List<String> ids = generateIds(3); this.stopWatch(); Vertex v1 = graph.addVertex(convertId(ids.get(0))); Vertex v2 = graph.addVertex(convertId(ids.get(1))); Vertex v3 = graph.addVertex(convertId(ids.get(2))); graph.addEdge(null, v1, v2, convertId("knows")); graph.addEdge(null, v2, v3, convertId("pets")); graph.addEdge(null, v2, v3, convertId("cares_for")); assertEquals(1, count(v1.getOutEdges())); assertEquals(2, count(v2.getOutEdges())); assertEquals(0, count(v3.getOutEdges())); assertEquals(0, count(v1.getInEdges())); assertEquals(1, count(v2.getInEdges())); assertEquals(2, count(v3.getInEdges())); BaseTest.printPerformance(graph.toString(), 6, "elements added and checked", this.stopWatch()); graph.shutdown(); }
public void testStringRepresentationOfVertexId() { final Graph graph = graphTest.generateGraph(); final Vertex a = graph.addVertex(null); final Object id = a.getId(); final Vertex b = graph.getVertex(id); final Vertex c = graph.getVertex(id.toString()); assertEquals(a, b); assertEquals(b, c); assertEquals(c, a); graph.shutdown(); }