public void testStringRepresentation() { Graph graph = graphTest.generateGraph(); try { this.stopWatch(); assertNotNull(graph.toString()); assertTrue(graph.toString().startsWith(graph.getClass().getSimpleName().toLowerCase())); printPerformance( graph.toString(), 1, "graph string representation generated", this.stopWatch()); } catch (Exception e) { assertFalse(true); } 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 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 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()); } }
public void testVertexIterator(final Graph graph) { int vertexCount = 5000; if (config.supportsVertexIteration) { this.stopWatch(); Set ids = new HashSet(); for (int i = 0; i < vertexCount; i++) { ids.add(graph.addVertex(null).getId()); } BaseTest.printPerformance(graph.toString(), vertexCount, "vertices added", this.stopWatch()); this.stopWatch(); assertEquals(vertexCount, count(graph.getVertices())); BaseTest.printPerformance( graph.toString(), vertexCount, "vertices counted", this.stopWatch()); // must create unique ids assertEquals(vertexCount, ids.size()); } }
public void testReadingTinkerGraph(Graph graph) throws Exception { if (!config.ignoresSuppliedIds) { this.stopWatch(); GraphMLReader.inputGraph( graph, GraphMLReader.class.getResourceAsStream("graph-example-1.xml")); BaseTest.printPerformance(graph.toString(), null, "graph-example-1 loaded", this.stopWatch()); assertEquals(count(graph.getVertex("1").getOutEdges()), 3); assertEquals(count(graph.getVertex("1").getInEdges()), 0); Vertex marko = graph.getVertex("1"); assertEquals(marko.getProperty("name"), "marko"); assertEquals(marko.getProperty("age"), 29); int counter = 0; for (Edge e : graph.getVertex("1").getOutEdges()) { if (e.getInVertex().getId().equals("2")) { // assertEquals(e.getProperty("weight"), 0.5); assertEquals(e.getLabel(), "knows"); assertEquals(e.getId(), "7"); counter++; } else if (e.getInVertex().getId().equals("3")) { assertEquals(Math.round((Float) e.getProperty("weight")), 0); assertEquals(e.getLabel(), "created"); assertEquals(e.getId(), "9"); counter++; } else if (e.getInVertex().getId().equals("4")) { assertEquals(Math.round((Float) e.getProperty("weight")), 1); assertEquals(e.getLabel(), "knows"); assertEquals(e.getId(), "8"); counter++; } } assertEquals(count(graph.getVertex("4").getOutEdges()), 2); assertEquals(count(graph.getVertex("4").getInEdges()), 1); Vertex josh = graph.getVertex("4"); assertEquals(josh.getProperty("name"), "josh"); assertEquals(josh.getProperty("age"), 32); for (Edge e : graph.getVertex("4").getOutEdges()) { if (e.getInVertex().getId().equals("3")) { assertEquals(Math.round((Float) e.getProperty("weight")), 0); assertEquals(e.getLabel(), "created"); assertEquals(e.getId(), "11"); counter++; } else if (e.getInVertex().getId().equals("5")) { assertEquals(Math.round((Float) e.getProperty("weight")), 1); assertEquals(e.getLabel(), "created"); assertEquals(e.getId(), "10"); counter++; } } assertEquals(counter, 5); } }
public void testRemovingVertices() { Graph graph = graphTest.generateGraph(); int vertexCount = 500; List<Vertex> vertices = new ArrayList<Vertex>(); List<Edge> edges = new ArrayList<Edge>(); this.stopWatch(); for (int i = 0; i < vertexCount; i++) { vertices.add(graph.addVertex(null)); } printPerformance(graph.toString(), vertexCount, "vertices added", this.stopWatch()); this.stopWatch(); for (int i = 0; i < vertexCount; i = i + 2) { Vertex a = vertices.get(i); Vertex b = vertices.get(i + 1); edges.add(graph.addEdge(null, a, b, convertId(graph, "a" + UUID.randomUUID()))); } printPerformance(graph.toString(), vertexCount / 2, "edges added", this.stopWatch()); this.stopWatch(); int counter = 0; for (Vertex v : vertices) { counter = counter + 1; graph.removeVertex(v); if ((counter + 1) % 2 == 0) { if (graph.getFeatures().supportsEdgeIteration) { assertEquals(edges.size() - ((counter + 1) / 2), count(graph.getEdges())); } } if (graph.getFeatures().supportsVertexIteration) { assertEquals(vertices.size() - counter, count(graph.getVertices())); } } printPerformance( graph.toString(), vertexCount, "vertices deleted (with size check on each delete)", this.stopWatch()); graph.shutdown(); }
public void testRemovingEdges() { Graph graph = graphTest.generateGraph(); int vertexCount = 100; int edgeCount = 200; List<Vertex> vertices = new ArrayList<Vertex>(); List<Edge> edges = new ArrayList<Edge>(); Random random = new Random(); this.stopWatch(); for (int i = 0; i < vertexCount; i++) { vertices.add(graph.addVertex(null)); } printPerformance(graph.toString(), vertexCount, "vertices added", this.stopWatch()); this.stopWatch(); for (int i = 0; i < edgeCount; i++) { Vertex a = vertices.get(random.nextInt(vertices.size())); Vertex b = vertices.get(random.nextInt(vertices.size())); if (a != b) { edges.add(graph.addEdge(null, a, b, convertId(graph, "a" + UUID.randomUUID()))); } } printPerformance(graph.toString(), edgeCount, "edges added", this.stopWatch()); this.stopWatch(); int counter = 0; for (Edge e : edges) { counter = counter + 1; graph.removeEdge(e); if (graph.getFeatures().supportsEdgeIteration) { assertEquals(edges.size() - counter, count(graph.getEdges())); } if (graph.getFeatures().supportsVertexIteration) { assertEquals(vertices.size(), count(graph.getVertices())); } } printPerformance( graph.toString(), edgeCount, "edges deleted (with size check on each delete)", this.stopWatch()); graph.shutdown(); }
public void testAddManyEdges() { Graph graph = graphTest.getGraphInstance(); int edgeCount = 1000; int vertexCount = 2000; long counter = 0l; this.stopWatch(); for (int i = 0; i < edgeCount; i++) { Vertex out = graph.addVertex(convertId("" + counter++)); Vertex in = graph.addVertex(convertId("" + counter++)); graph.addEdge(null, out, in, convertId(UUID.randomUUID().toString())); } BaseTest.printPerformance( graph.toString(), vertexCount + edgeCount, "elements added", this.stopWatch()); if (graphTest.supportsEdgeIteration) { this.stopWatch(); assertEquals(edgeCount, count(graph.getEdges())); BaseTest.printPerformance(graph.toString(), edgeCount, "edges counted", this.stopWatch()); } if (graphTest.supportsVertexIteration) { this.stopWatch(); assertEquals(vertexCount, count(graph.getVertices())); BaseTest.printPerformance( graph.toString(), vertexCount, "vertices counted", this.stopWatch()); this.stopWatch(); for (Vertex vertex : graph.getVertices()) { if (count(vertex.getOutEdges()) > 0) { assertEquals(1, count(vertex.getOutEdges())); assertFalse(count(vertex.getInEdges()) > 0); } else { assertEquals(1, count(vertex.getInEdges())); assertFalse(count(vertex.getOutEdges()) > 0); } } BaseTest.printPerformance( graph.toString(), vertexCount, "vertices checked", this.stopWatch()); } graph.shutdown(); }
public void testRemoveVertexNullId(final Graph graph) { int vertexCount = 1000; Vertex v1 = graph.addVertex(null); 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>(); this.stopWatch(); for (int i = 0; i < vertexCount; i++) { vertices.add(graph.addVertex(null)); } BaseTest.printPerformance(graph.toString(), vertexCount, "vertices added", this.stopWatch()); if (config.supportsVertexIteration) assertEquals(vertexCount, count(graph.getVertices())); this.stopWatch(); for (Vertex v : vertices) { graph.removeVertex(v); } BaseTest.printPerformance(graph.toString(), vertexCount, "vertices deleted", this.stopWatch()); if (config.supportsVertexIteration) assertEquals(0, count(graph.getVertices())); }
@Test public void shouldHaveNoCycles() { Graph<String> graph = new Graph<>(); packageDependencies.forEach( (key, set) -> { Node<String> node = graph.findOrCreateNode(key); set.stream() .filter(packageDependencies::containsKey) .forEach(target -> node.linkedTo(graph.findOrCreateNode(target))); }); graph.topologicalSort(); System.out.println("----------------------- dependencies:"); System.out.println(graph.toString()); System.out.println("-----------------------"); }
public void testGraphDataPersists() { Graph graph = graphTest.generateGraph(); if (graph.getFeatures().isPersistent) { Vertex v = graph.addVertex(null); Vertex u = graph.addVertex(null); if (graph.getFeatures().supportsVertexProperties) { v.setProperty("name", "marko"); u.setProperty("name", "pavel"); } Edge e = graph.addEdge(null, v, u, convertId(graph, "collaborator")); if (graph.getFeatures().supportsEdgeProperties) e.setProperty("location", "internet"); if (graph.getFeatures().supportsVertexIteration) { assertEquals(count(graph.getVertices()), 2); } if (graph.getFeatures().supportsEdgeIteration) { assertEquals(count(graph.getEdges()), 1); } graph.shutdown(); this.stopWatch(); graph = graphTest.generateGraph(); printPerformance(graph.toString(), 1, "graph loaded", this.stopWatch()); if (graph.getFeatures().supportsVertexIteration) { assertEquals(count(graph.getVertices()), 2); if (graph.getFeatures().supportsVertexProperties) { for (Vertex vertex : graph.getVertices()) { assertTrue( vertex.getProperty("name").equals("marko") || vertex.getProperty("name").equals("pavel")); } } } if (graph.getFeatures().supportsEdgeIteration) { assertEquals(count(graph.getEdges()), 1); for (Edge edge : graph.getEdges()) { assertEquals(edge.getLabel(), convertId(graph, "collaborator")); if (graph.getFeatures().supportsEdgeProperties) assertEquals(edge.getProperty("location"), "internet"); } } } 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 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 testGetEdges() { Graph graph = graphTest.generateGraph(); Vertex v1 = graph.addVertex(null); Vertex v2 = graph.addVertex(null); Vertex v3 = graph.addVertex(null); Edge e1 = graph.addEdge(null, v1, v2, convertId(graph, "test1")); Edge e2 = graph.addEdge(null, v2, v3, convertId(graph, "test2")); Edge e3 = graph.addEdge(null, v3, v1, convertId(graph, "test3")); if (graph.getFeatures().supportsEdgeRetrieval) { this.stopWatch(); assertEquals(graph.getEdge(e1.getId()), e1); assertEquals(graph.getEdge(e1.getId()).getVertex(Direction.IN), v2); assertEquals(graph.getEdge(e1.getId()).getVertex(Direction.OUT), v1); assertEquals(graph.getEdge(e2.getId()), e2); assertEquals(graph.getEdge(e2.getId()).getVertex(Direction.IN), v3); assertEquals(graph.getEdge(e2.getId()).getVertex(Direction.OUT), v2); assertEquals(graph.getEdge(e3.getId()), e3); assertEquals(graph.getEdge(e3.getId()).getVertex(Direction.IN), v1); assertEquals(graph.getEdge(e3.getId()).getVertex(Direction.OUT), v3); printPerformance(graph.toString(), 3, "edges retrieved", this.stopWatch()); } assertEquals(getOnlyElement(v1.getEdges(Direction.OUT)), e1); assertEquals(getOnlyElement(v1.getEdges(Direction.OUT)).getVertex(Direction.IN), v2); assertEquals(getOnlyElement(v1.getEdges(Direction.OUT)).getVertex(Direction.OUT), v1); assertEquals(getOnlyElement(v2.getEdges(Direction.OUT)), e2); assertEquals(getOnlyElement(v2.getEdges(Direction.OUT)).getVertex(Direction.IN), v3); assertEquals(getOnlyElement(v2.getEdges(Direction.OUT)).getVertex(Direction.OUT), v2); assertEquals(getOnlyElement(v3.getEdges(Direction.OUT)), e3); assertEquals(getOnlyElement(v3.getEdges(Direction.OUT)).getVertex(Direction.IN), v1); assertEquals(getOnlyElement(v3.getEdges(Direction.OUT)).getVertex(Direction.OUT), v3); graph.shutdown(); }
public void testTinkerGraphSoftwareVertices(Graph graph) throws Exception { if (config.supportsVertexIteration) { this.stopWatch(); GraphMLReader.inputGraph( graph, GraphMLReader.class.getResourceAsStream("graph-example-1.xml")); BaseTest.printPerformance(graph.toString(), null, "graph-example-1 loaded", this.stopWatch()); Set<Vertex> softwareVertices = new HashSet<Vertex>(); int count = 0; for (Vertex v : graph.getVertices()) { count++; String name = v.getProperty("name").toString(); if (name.equals("lop") || name.equals("ripple")) { softwareVertices.add(v); } } assertEquals(count, 6); assertEquals(softwareVertices.size(), 2); for (Vertex v : softwareVertices) { assertEquals(v.getProperty("lang"), "java"); } } }
public void testTinkerGraphVertices(Graph graph) throws Exception { if (config.supportsVertexIteration) { this.stopWatch(); GraphMLReader.inputGraph( graph, GraphMLReader.class.getResourceAsStream("graph-example-1.xml")); BaseTest.printPerformance(graph.toString(), null, "graph-example-1 loaded", this.stopWatch()); Set<String> vertexNames = new HashSet<String>(); int count = 0; for (Vertex v : graph.getVertices()) { count++; vertexNames.add(v.getProperty("name").toString()); // System.out.println(v); } assertEquals(count, 6); assertEquals(vertexNames.size(), 6); assertTrue(vertexNames.contains("marko")); assertTrue(vertexNames.contains("josh")); assertTrue(vertexNames.contains("peter")); assertTrue(vertexNames.contains("vadas")); assertTrue(vertexNames.contains("ripple")); assertTrue(vertexNames.contains("lop")); } }
public void testTinkerGraphEdges(Graph graph) throws Exception { if (config.supportsEdgeIteration) { this.stopWatch(); GraphMLReader.inputGraph( graph, GraphMLReader.class.getResourceAsStream("graph-example-1.xml")); BaseTest.printPerformance(graph.toString(), null, "graph-example-1 loaded", this.stopWatch()); Set<String> edgeIds = new HashSet<String>(); Set<String> edgeKeys = new HashSet<String>(); Set<String> edgeValues = new HashSet<String>(); int count = 0; for (Edge e : graph.getEdges()) { count++; edgeIds.add(e.getId().toString()); for (String key : e.getPropertyKeys()) { edgeKeys.add(key); edgeValues.add(e.getProperty(key).toString()); } } assertEquals(count, 6); assertEquals(edgeIds.size(), 6); assertEquals(edgeKeys.size(), 1); assertEquals(edgeValues.size(), 4); } }
public void testTinkerGraphVertexAndEdges(Graph graph) throws Exception { if (config.supportsVertexIteration) { this.stopWatch(); GraphMLReader.inputGraph( graph, GraphMLReader.class.getResourceAsStream("graph-example-1.xml")); BaseTest.printPerformance(graph.toString(), null, "graph-example-1 loaded", this.stopWatch()); Vertex marko = null; Vertex peter = null; Vertex josh = null; Vertex vadas = null; Vertex lop = null; Vertex ripple = null; int count = 0; for (Vertex v : graph.getVertices()) { count++; String name = v.getProperty("name").toString(); if (name.equals("marko")) { marko = v; } else if (name.equals("peter")) { peter = v; } else if (name.equals("josh")) { josh = v; } else if (name.equals("vadas")) { vadas = v; } else if (name.equals("lop")) { lop = v; } else if (name.equals("ripple")) { ripple = v; } else { assertTrue(false); } } assertEquals(count, 6); assertTrue(null != marko); assertTrue(null != peter); assertTrue(null != josh); assertTrue(null != vadas); assertTrue(null != lop); assertTrue(null != ripple); // test marko Set<Vertex> vertices = new HashSet<Vertex>(); assertEquals(marko.getProperty("name"), "marko"); assertEquals(marko.getProperty("age"), 29); assertEquals(marko.getPropertyKeys().size(), 2); assertEquals(count(marko.getOutEdges()), 3); assertEquals(count(marko.getInEdges()), 0); for (Edge e : marko.getOutEdges()) { vertices.add(e.getInVertex()); } assertEquals(vertices.size(), 3); assertTrue(vertices.contains(lop)); assertTrue(vertices.contains(josh)); assertTrue(vertices.contains(vadas)); // test peter vertices = new HashSet<Vertex>(); assertEquals(peter.getProperty("name"), "peter"); assertEquals(peter.getProperty("age"), 35); assertEquals(peter.getPropertyKeys().size(), 2); assertEquals(count(peter.getOutEdges()), 1); assertEquals(count(peter.getInEdges()), 0); for (Edge e : peter.getOutEdges()) { vertices.add(e.getInVertex()); } assertEquals(vertices.size(), 1); assertTrue(vertices.contains(lop)); // test josh vertices = new HashSet<Vertex>(); assertEquals(josh.getProperty("name"), "josh"); assertEquals(josh.getProperty("age"), 32); assertEquals(josh.getPropertyKeys().size(), 2); assertEquals(count(josh.getOutEdges()), 2); assertEquals(count(josh.getInEdges()), 1); for (Edge e : josh.getOutEdges()) { vertices.add(e.getInVertex()); } assertEquals(vertices.size(), 2); assertTrue(vertices.contains(lop)); assertTrue(vertices.contains(ripple)); vertices = new HashSet<Vertex>(); for (Edge e : josh.getInEdges()) { vertices.add(e.getOutVertex()); } assertEquals(vertices.size(), 1); assertTrue(vertices.contains(marko)); // test vadas vertices = new HashSet<Vertex>(); assertEquals(vadas.getProperty("name"), "vadas"); assertEquals(vadas.getProperty("age"), 27); assertEquals(vadas.getPropertyKeys().size(), 2); assertEquals(count(vadas.getOutEdges()), 0); assertEquals(count(vadas.getInEdges()), 1); for (Edge e : vadas.getInEdges()) { vertices.add(e.getOutVertex()); } assertEquals(vertices.size(), 1); assertTrue(vertices.contains(marko)); // test lop vertices = new HashSet<Vertex>(); assertEquals(lop.getProperty("name"), "lop"); assertEquals(lop.getProperty("lang"), "java"); assertEquals(lop.getPropertyKeys().size(), 2); assertEquals(count(lop.getOutEdges()), 0); assertEquals(count(lop.getInEdges()), 3); for (Edge e : lop.getInEdges()) { vertices.add(e.getOutVertex()); } assertEquals(vertices.size(), 3); assertTrue(vertices.contains(marko)); assertTrue(vertices.contains(josh)); assertTrue(vertices.contains(peter)); // test ripple vertices = new HashSet<Vertex>(); assertEquals(ripple.getProperty("name"), "ripple"); assertEquals(ripple.getProperty("lang"), "java"); assertEquals(ripple.getPropertyKeys().size(), 2); assertEquals(count(ripple.getOutEdges()), 0); assertEquals(count(ripple.getInEdges()), 1); for (Edge e : ripple.getInEdges()) { vertices.add(e.getOutVertex()); } assertEquals(vertices.size(), 1); assertTrue(vertices.contains(josh)); } }
public void testTreeConnectivity() { Graph graph = graphTest.generateGraph(); this.stopWatch(); int branchSize = 11; Vertex start = graph.addVertex(null); for (int i = 0; i < branchSize; i++) { Vertex a = graph.addVertex(null); graph.addEdge(null, start, a, convertId(graph, "test1")); for (int j = 0; j < branchSize; j++) { Vertex b = graph.addVertex(null); graph.addEdge(null, a, b, convertId(graph, "test2")); for (int k = 0; k < branchSize; k++) { Vertex c = graph.addVertex(null); graph.addEdge(null, b, c, convertId(graph, "test3")); } } } assertEquals(0, count(start.getEdges(Direction.IN))); assertEquals(branchSize, count(start.getEdges(Direction.OUT))); for (Edge e : start.getEdges(Direction.OUT)) { assertEquals(convertId(graph, "test1"), e.getLabel()); assertEquals(branchSize, count(e.getVertex(Direction.IN).getEdges(Direction.OUT))); assertEquals(1, count(e.getVertex(Direction.IN).getEdges(Direction.IN))); for (Edge f : e.getVertex(Direction.IN).getEdges(Direction.OUT)) { assertEquals(convertId(graph, "test2"), f.getLabel()); assertEquals(branchSize, count(f.getVertex(Direction.IN).getEdges(Direction.OUT))); assertEquals(1, count(f.getVertex(Direction.IN).getEdges(Direction.IN))); for (Edge g : f.getVertex(Direction.IN).getEdges(Direction.OUT)) { assertEquals(convertId(graph, "test3"), g.getLabel()); assertEquals(0, count(g.getVertex(Direction.IN).getEdges(Direction.OUT))); assertEquals(1, count(g.getVertex(Direction.IN).getEdges(Direction.IN))); } } } int totalVertices = 0; for (int i = 0; i < 4; i++) { totalVertices = totalVertices + (int) Math.pow(branchSize, i); } printPerformance( graph.toString(), totalVertices, "vertices added in a tree structure", this.stopWatch()); if (graph.getFeatures().supportsVertexIteration) { this.stopWatch(); Set<Vertex> vertices = new HashSet<Vertex>(); for (Vertex v : graph.getVertices()) { vertices.add(v); } assertEquals(totalVertices, vertices.size()); printPerformance(graph.toString(), totalVertices, "vertices iterated", this.stopWatch()); } if (graph.getFeatures().supportsEdgeIteration) { this.stopWatch(); Set<Edge> edges = new HashSet<Edge>(); for (Edge e : graph.getEdges()) { edges.add(e); } assertEquals(totalVertices - 1, edges.size()); printPerformance(graph.toString(), totalVertices - 1, "edges iterated", this.stopWatch()); } graph.shutdown(); }