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();
}
