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