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 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();
}
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();
}
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 createGraph() {
int N = 100;
int T = 10;
int x = 0;
int y = 0;
Random rando = new Random();
ArrayList<String> usedPositions = new ArrayList();
// Create vertices
for (int i = 0; i < N; i++) {
do {
x = rando.nextInt(100) + 1;
y = rando.nextInt(100) + 1;
} while (usedPositions.contains(x + "," + y));
usedPositions.add(x + "," + y);
graph.insertVertex(new Node(x, y));
}
// Create edges
// n^2
for (Graph.Vertex v1 : graph.getVertices()) {
for (Graph.Vertex v2 : graph.getVertices()) {
Node n1 = (Node) v1.getElement();
Node n2 = (Node) v2.getElement();
if (n1.equals(n2)) {
continue;
}
double distance = Math.sqrt(Math.pow((n1.x - n2.x), 2) + Math.pow((n1.y - n2.y), 2));
if (distance <= T) {
if (graph.insertEdge(distance, v1, v2)) {
// plotter.connectCircles(plotter.getCircles().get(n1.index),
// plotter.getCircles().get(n2.index));
plotter.drawLine(n1.x, n1.y, n2.x, n2.y);
// System.out.println("(" + n1.x + "," + n1.y + ")" + "," + "(" + n2.x + "," + n2.y +
// ")");
}
}
}
}
}
@Before
public void setUp() throws Exception {
tested = new Graph();
for (int i = 0; i < 5; i++) {
VertexTest newVertex = new VertexTest(i);
tested.addVertex(newVertex);
}
for (int i = 0; i < 4; i++) {
EdgeTest newEdge = new EdgeTest(tested.getVertices().get(i), tested.getVertices().get(i + 1));
tested.addEdge(newEdge);
}
}
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 testRemoveVertexWithEdges(final Graph graph) {
List<String> ids = generateIds(2);
Vertex v1 = graph.addVertex(convertId(ids.get(0)));
Vertex v2 = graph.addVertex(convertId(ids.get(1)));
graph.addEdge(null, v1, v2, convertId("knows"));
if (config.supportsVertexIteration) assertEquals(2, count(graph.getVertices()));
if (config.supportsEdgeIteration) assertEquals(1, count(graph.getEdges()));
graph.removeVertex(v1);
if (config.supportsVertexIteration) assertEquals(1, count(graph.getVertices()));
if (config.supportsEdgeIteration) assertEquals(0, count(graph.getEdges()));
graph.removeVertex(v2);
if (config.supportsVertexIteration) assertEquals(0, count(graph.getVertices()));
if (config.supportsEdgeIteration) assertEquals(0, count(graph.getEdges()));
}
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 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 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();
}
/**
* Creates an SPQRTree.
*
* @param g Create the tree for this graph.
*/
public SPQRTree(Graph g, Pair<Integer, Integer> atEdge) {
rootNode = null;
nodeId2NodePointer = new HashMap<Integer, Integer>();
nodePointer2NodeId = new HashMap<Integer, Integer>();
treeNode2TreeNodePtr = new HashMap<SPQRTreeNode, Integer>();
int graphPointer = createGraph();
for (Integer v : g.getVertices()) {
int nodePointer = addNode(graphPointer);
nodeId2NodePointer.put(v, nodePointer);
nodePointer2NodeId.put(nodePointer, v);
}
Integer atEdgePtr = null;
for (Pair<Integer, Integer> e : g.getEdges()) {
int eptr =
addEdge(
graphPointer,
nodeId2NodePointer.get(Pair.get1(e)),
nodeId2NodePointer.get(Pair.get2(e)));
if (e.equals(atEdge)) {
atEdgePtr = eptr;
}
}
int spqrTreePointer =
(atEdgePtr == null)
? createSPQRTree(graphPointer)
: createSPQRTree(graphPointer, atEdgePtr);
rootNode = new SPQRTreeNode();
int rootNodePointer = spqrRootNode(spqrTreePointer);
addSPQRTreeNodeAndChildren(spqrTreePointer, rootNodePointer, rootNode);
orderSNodes(rootNode);
}
@Test
public void test() {
KeyPad keyPad = new KeyPadBuilder().append("ABC", "DEF", "GHI").build();
assertEquals(3, keyPad.getRowSize());
assertEquals(new Point(3, 3), keyPad.getBoundary());
Graph graph = new KeyPadToGraphFunction().valueOf(keyPad);
assertEquals(8, graph.getEdges());
Set<String> set = graph.getVertices("E");
assertNull(set);
set = graph.getVertices("F");
assertEquals(2, set.size());
assertTrue(set.contains("A"));
assertTrue(set.contains("G"));
}
private void populateLists(List<Vertex> verticies, List<Edge> edges) {
for (Vertex v : graph.getVertices()) {
verticies.add(v);
}
for (Edge e : graph.getEdges()) {
edges.add(e);
}
}
@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 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 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();
}
private Vertex findSingleVertex() {
Vertex vertex = selection.getAnyVertex();
// if there is no selection we select an existing vertex
if (vertex == null) {
vertex = (Vertex) graph.getVertices().next();
}
return vertex;
}
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 static <V, E> void customTraverse(
final Graph<V, E> graph, final V startNode, final TraversalCallback<V, E> handler) {
Set<V> traversedNodes = new HashSet<V>();
Queue<VertexHolder<V>> traversalQueue = new PriorityQueue<VertexHolder<V>>(16);
int counter = 0;
traversalQueue.add(new VertexHolder<V>(startNode, counter++, 0));
boolean done = false;
do {
boolean first = true;
while (!traversalQueue.isEmpty()) {
V node = traversalQueue.remove().getVertex();
VertexEdges<V, E> edges = graph.getEdges(node);
if (traversedNodes.contains(node)) {
continue;
}
Map<E, V> incomming = edges.getIncomming();
boolean hasIncomingBeenTraversed = true;
for (V val : incomming.values()) {
if (!traversedNodes.contains(val)) {
hasIncomingBeenTraversed = false;
break;
}
}
if (!first && !hasIncomingBeenTraversed) {
continue;
}
handler.handle(node, incomming);
traversedNodes.add(node);
first = false;
Map<E, V> outgoing = edges.getOutgoing();
for (V next : outgoing.values()) {
traversalQueue.add(
new VertexHolder<V>(next, counter++, graph.getEdges(next).getIncomming().size()));
}
}
Set<V> leftNodes = Sets.difference(graph.getVertices(), traversedNodes);
if (leftNodes.isEmpty()) {
done = true;
} else {
boolean added = false;
for (V node : leftNodes) {
Collection<V> incomingNodes = graph.getEdges(node).getIncomming().values();
for (V incoming : incomingNodes) {
if (traversedNodes.contains(incoming)) {
traversalQueue.add(new VertexHolder<V>(node, counter++, 0));
added = true;
break;
}
}
if (added) {
break;
}
}
}
} while (!done);
}
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 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 testGettingVerticesAndEdgesWithKeyValue() {
Graph graph = graphTest.generateGraph();
if (graph.getFeatures().supportsVertexProperties) {
Vertex v1 = graph.addVertex(null);
v1.setProperty("name", "marko");
v1.setProperty("location", "everywhere");
Vertex v2 = graph.addVertex(null);
v2.setProperty("name", "stephen");
v2.setProperty("location", "everywhere");
if (graph.getFeatures().supportsVertexIteration) {
assertEquals(count(graph.getVertices("location", "everywhere")), 2);
assertEquals(count(graph.getVertices("name", "marko")), 1);
assertEquals(count(graph.getVertices("name", "stephen")), 1);
assertEquals(getOnlyElement(graph.getVertices("name", "marko")), v1);
assertEquals(getOnlyElement(graph.getVertices("name", "stephen")), v2);
}
}
if (graph.getFeatures().supportsEdgeProperties) {
Edge e1 =
graph.addEdge(
null, graph.addVertex(null), graph.addVertex(null), convertId(graph, "knows"));
e1.setProperty("name", "marko");
e1.setProperty("location", "everywhere");
Edge e2 =
graph.addEdge(
null, graph.addVertex(null), graph.addVertex(null), convertId(graph, "knows"));
e2.setProperty("name", "stephen");
e2.setProperty("location", "everywhere");
if (graph.getFeatures().supportsEdgeIteration) {
assertEquals(count(graph.getEdges("location", "everywhere")), 2);
assertEquals(count(graph.getEdges("name", "marko")), 1);
assertEquals(count(graph.getEdges("name", "stephen")), 1);
assertEquals(graph.getEdges("name", "marko").iterator().next(), e1);
assertEquals(graph.getEdges("name", "stephen").iterator().next(), e2);
}
}
graph.shutdown();
}
public void testAddVertex(final Graph graph) {
if (config.supportsVertexIteration) {
List<String> ids = generateIds(3);
graph.addVertex(convertId(ids.get(0)));
graph.addVertex(convertId(ids.get(1)));
assertEquals(2, count(graph.getVertices()));
graph.addVertex(convertId(ids.get(2)));
assertEquals(3, count(graph.getVertices()));
}
if (config.isRDFModel && config.requiresRDFIds) {
Vertex v1 = graph.addVertex("http://tinkerpop.com#marko");
assertEquals("http://tinkerpop.com#marko", v1.getId());
Vertex v2 = graph.addVertex("\"1\"^^<datatype:int>");
assertEquals("\"1\"^^<datatype:int>", v2.getId());
Vertex v3 = graph.addVertex("_:ABLANKNODE");
assertEquals(v3.getId(), "_:ABLANKNODE");
Vertex v4 = graph.addVertex("\"2.24\"^^<xsd:double>");
assertEquals("\"2.24\"^^<http://www.w3.org/2001/XMLSchema#double>", v4.getId());
}
}
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 testSimpleRemovingVerticesEdges() {
Graph graph = graphTest.generateGraph();
Vertex v = graph.addVertex(null);
Vertex u = graph.addVertex(null);
Edge e = graph.addEdge(null, v, u, convertId(graph, "knows"));
if (graph.getFeatures().supportsVertexIteration) assertEquals(count(graph.getVertices()), 2);
if (graph.getFeatures().supportsEdgeIteration) assertEquals(count(graph.getEdges()), 1);
assertEquals(v.getEdges(Direction.OUT).iterator().next().getVertex(Direction.IN), u);
assertEquals(u.getEdges(Direction.IN).iterator().next().getVertex(Direction.OUT), v);
assertEquals(v.getEdges(Direction.OUT).iterator().next(), e);
assertEquals(u.getEdges(Direction.IN).iterator().next(), e);
graph.removeVertex(v);
// TODO: DEX
// assertFalse(v.getEdges(Direction.OUT).iterator().hasNext());
if (graph.getFeatures().supportsVertexIteration) assertEquals(count(graph.getVertices()), 1);
if (graph.getFeatures().supportsEdgeIteration) assertEquals(count(graph.getEdges()), 0);
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()));
}
public void testAddingDuplicateEdges() {
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"));
graph.addEdge(null, v2, v3, convertId("pets"));
graph.addEdge(null, v2, v3, convertId("pets"));
if (graphTest.allowsDuplicateEdges) {
if (graphTest.supportsVertexIteration) assertEquals(3, count(graph.getVertices()));
if (graphTest.supportsEdgeIteration) assertEquals(5, count(graph.getEdges()));
assertEquals(0, count(v1.getInEdges()));
assertEquals(1, count(v1.getOutEdges()));
assertEquals(1, count(v2.getInEdges()));
assertEquals(4, count(v2.getOutEdges()));
assertEquals(4, count(v3.getInEdges()));
assertEquals(0, count(v3.getOutEdges()));
} else {
if (graphTest.supportsVertexIteration) assertEquals(count(graph.getVertices()), 3);
if (graphTest.supportsEdgeIteration) assertEquals(count(graph.getEdges()), 2);
assertEquals(0, count(v1.getInEdges()));
assertEquals(1, count(v1.getOutEdges()));
assertEquals(1, count(v2.getInEdges()));
assertEquals(1, count(v2.getOutEdges()));
assertEquals(1, count(v3.getInEdges()));
assertEquals(0, count(v3.getOutEdges()));
}
graph.shutdown();
}
public static void main(String[] args) {
Graph g = new Graph();
Vertex pre = null;
for (int i = 0; i < 10; i++) {
Vertex v = new Vertex();
v.assignName("vertex " + i);
g.addVertex(v);
if (pre != null) {
g.addEdge(pre, v);
}
pre = v;
}
g.run(g.getVertices().next());
g.display();
}
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());
}
}
