AbstractGraphTest.java
package org.graphstream.graph.implementations;
import static org.junit.Assert.*;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Iterator;
import org.graphstream.graph.Edge;
import org.graphstream.graph.EdgeFactory;
import org.graphstream.graph.EdgeRejectedException;
import org.graphstream.graph.ElementNotFoundException;
import org.graphstream.graph.IdAlreadyInUseException;
import org.graphstream.graph.Node;
import org.graphstream.graph.NodeFactory;
import org.graphstream.graph.implementations.AbstractGraph.GraphListeners;
import org.graphstream.stream.Sink;
import org.graphstream.stream.SinkAdapter;
import org.junit.Assert;
import org.junit.Test;
public class AbstractGraphTest {
/* Add Edge tests */
/*
* Checks that, if the ID of the edge already exists and Strict checking is
* enabled, IdAlreadyInUseException is thrown
*/
@Test
public void addEdgeTestExistenceStrictChecking() {
AbstractGraph ag = new SingleGraph("graph", true, false);
ag.addNode("node1");
ag.addNode("node2");
AbstractNode node1 = ag.getNode("node1");
AbstractNode node2 = ag.getNode("node2");
AbstractEdge edge1 = new AbstractEdge("edge_1", node1, node2, true);
AbstractEdge edge2 = new AbstractEdge("edge_1", node1, node2, true);
ag.addEdge("edge_1", node1, node2);
try {
ag.addEdge("edge_1", node1, node2);
fail("should not add edge");
} catch (IdAlreadyInUseException e) {
System.err.println(e.getMessage() + "\n");
}
}
@Test
public void addEdgeTestExistenceNoStrictCheckingSameOrder() {
AbstractGraph ag = new SingleGraph("graph", false, false);
ag.addNode("node1");
ag.addNode("node2");
AbstractNode node1 = ag.getNode("node1");
AbstractNode node2 = ag.getNode("node2");
Edge old = ag.addEdge("edge_1", node1, node2);
Edge new_ = ag.addEdge("edge_1", node1, node2);
assertEquals(old, new_);
}
@Test
public void addEdgeTestExistenceNoStrictCheckingInverseOrder() {
AbstractGraph ag = new SingleGraph("graph", false, false);
ag.addNode("node1");
ag.addNode("node2");
AbstractNode node1 = ag.getNode("node1");
AbstractNode node2 = ag.getNode("node2");
Edge old = ag.addEdge("edge_1", node1, node2);
Edge new_ = ag.addEdge("edge_1", node2, node1);
assertEquals(old, new_);
}
@Test
public void addEdgeTestExistenceNoStrictCheckingReturnNull() {
AbstractGraph ag = new SingleGraph("graph", false, false);
ag.addNode("node1");
ag.addNode("node2");
ag.addNode("node3");
ag.addNode("node4");
AbstractNode node1 = ag.getNode("node1");
AbstractNode node2 = ag.getNode("node2");
AbstractNode node3 = ag.getNode("node3");
AbstractNode node4 = ag.getNode("node4");
Edge old = ag.addEdge("edge_1", node1, node2);
Edge new_ = ag.addEdge("edge_1", node3, node4);
assertEquals(null, new_);
}
@Test
public void addEdgeTestNoExistenceElementNotFoundStrictChecking() {
AbstractGraph ag = new SingleGraph("graph", true, false);
ag.addNode("node1");
try {
ag.addEdge("edge_1", "node1", "node2");
fail("should not add edge");
} catch (ElementNotFoundException e) {
System.err.println(e.getMessage() + "\n");
}
}
@Test
public void addEdgeTestNoExistenceNoStrictCheckingNoAutoMissingNode() {
AbstractGraph ag = new SingleGraph("graph", false, false);
ag.addNode("node1");
assertEquals(null, ag.addEdge("edge_1", "node1", "node2"));
}
@Test
public void addEdgeTestNoExistenceNoStrictCheckingAutoDstMissing() {
AbstractGraph ag = new SingleGraph("graph", false, true);
ag.addNode("node1");
ag.addEdge("edge_1", "node1", "node2");
assertEquals(2, ag.getNodeCount());
}
@Test
public void addEdgeTestNoExistenceNoStrictCheckingAutoSrcMissing() {
AbstractGraph ag = new SingleGraph("graph", false, true);
ag.addNode("node2");
ag.addEdge("edge_1", "node1", "node2");
assertEquals(2, ag.getNodeCount());
}
@Test
public void addEdgeTestNoExistenceStrictChecking() {
AbstractGraph ag = new SingleGraph("graph", true, true);
ag.addNode("node1");
ag.addNode("node2");
ag.addEdge("edge_1", "node1", "node2");
try {
ag.addEdge("edge_2", "node2", "node1");
fail("should not add edge");
} catch (EdgeRejectedException e) {
System.err.println(e.getMessage() + "\n");
}
}
@Test
public void addEdgeTestNoExistenceNoStrictCheckingNoAuto() {
AbstractGraph ag = new SingleGraph("graph", false, false);
ag.addNode("node1");
assertEquals(null, ag.addEdge("edge_1", "node1", "node2"));
}
@Test
public void addEdgeTestAccepted1() {
AbstractGraph ag = new SingleGraph("graph", false, false);
ag.addNode("node1");
ag.addNode("node2");
Edge edge1 = ag.addEdge("edge_1", 0, 1, false);
assertNotNull(edge1);
}
@Test
public void addEdgeTestAccepted2() {
AbstractGraph ag = new SingleGraph("graph", false, false);
ag.addNode("node1");
ag.addNode("node2");
Edge edge1 = ag.addEdge("edge_1", 0, 1);
assertNotNull(edge1);
}
@Test
public void addEdgeTestDegreeUpdated() {
AbstractGraph ag = new SingleGraph("graph");
ag.addNode("node1");
ag.addNode("node2");
AbstractNode node1 = ag.getNode("node1");
AbstractNode node2 = ag.getNode("node2");
Edge edge1 = ag.addEdge("edge1", node1, node2, false);
assertEquals(1, node1.getDegree());
}
// ----------------------------------------------------------------------
/* Remove Edge tests */
// @Test
// public void removeAllEdgesTest() {
// AbstractGraph graph = new SingleGraph("graph1");
//
// graph.addNode("node 1");
// graph.addNode("node 2");
// graph.addNode("node 3");
//
// AbstractNode node1 = graph.getNode("node 1");
// AbstractNode node2 = graph.getNode("node 2");
// AbstractNode node3 = graph.getNode("node 3");
//
// AbstractEdge edge1 = new AbstractEdge("edge_1", node1, node2,true);
// AbstractEdge edge2 = new AbstractEdge("edge_2", node1, node3,true);
//
// }
@Test
public void removeEdgeTestNodeNullStrictChecking() {
AbstractGraph ag = new SingleGraph("graph", true, false);
ag.addNode("node1");
ag.addNode("node2");
AbstractNode node1 = ag.getNode("node1");
AbstractNode node2 = ag.getNode("node2");
// Edge edge1 = new AbstractEdge("edge1", node1, node2, false);
try {
ag.removeEdge("edge1");
fail("should not remove edge");
} catch (ElementNotFoundException e) {
System.err.println(e.getMessage() + "\n");
}
}
@Test
public void removeEdgeTestNodeNullNoStrictChecking() {
AbstractGraph ag = new SingleGraph("graph", false, false);
ag.addNode("node1");
ag.addNode("node2");
AbstractNode node1 = ag.getNode("node1");
AbstractNode node2 = ag.getNode("node2");
// Edge edge1 = new AbstractEdge("edge1", node1, node2, false);
assertEquals(null, ag.removeEdge("edge1"));
}
@Test
public void removeEdgeTestEdge() {
AbstractGraph ag = new SingleGraph("graph", false, false);
ag.addNode("node1");
ag.addNode("node2");
AbstractNode node1 = ag.getNode("node1");
AbstractNode node2 = ag.getNode("node2");
Edge edge1 = ag.addEdge("edge_1", "node1", "node2", false);
ag.removeEdge(edge1);
assertEquals(0, ag.getEdgeCount());
}
@Test
public void removeEdgeTestEdgeNull() {
AbstractGraph ag = new SingleGraph("graph", false, false);
ag.addNode("node1");
ag.addNode("node2");
AbstractNode node1 = ag.getNode("node1");
AbstractNode node2 = ag.getNode("node2");
Edge edge1 = null;
assertEquals(null, ag.removeEdge(edge1));
}
@Test
public void removeEdgeTestIndex() {
AbstractGraph ag = new SingleGraph("graph", false, false);
ag.addNode("node1");
ag.addNode("node2");
AbstractNode node1 = ag.getNode("node1");
AbstractNode node2 = ag.getNode("node2");
Edge edge1 = ag.addEdge("edge_1", "node1", "node2", false);
ag.removeEdge(0);
assertEquals(0, ag.getEdgeCount());
}
@Test
public void removeEdgeTestFromToString() {
AbstractGraph ag = new SingleGraph("graph", false, false);
ag.addNode("node1");
ag.addNode("node2");
AbstractNode node1 = ag.getNode("node1");
AbstractNode node2 = ag.getNode("node2");
Edge edge1 = ag.addEdge("edge_1", "node1", "node2", false);
ag.removeEdge("node1", "node2");
assertEquals(0, ag.getEdgeCount());
}
@Test
public void removeEdgeTestFromToStringNullStrictChecking() {
AbstractGraph ag = new SingleGraph("graph", true, false);
ag.addNode("node1");
ag.addNode("node2");
AbstractNode node1 = ag.getNode("node1");
AbstractNode node2 = ag.getNode("node2");
Edge edge1 = ag.addEdge("edge_1", "node1", "node2", false);
try {
ag.removeEdge(null, "node2");
fail("should not remove edge");
} catch (ElementNotFoundException e) {
System.err.println(e.getMessage() + "\n");
}
}
@Test
public void removeEdgeTestFromToStringNullNoStrictChecking() {
AbstractGraph ag = new SingleGraph("graph", false, false);
ag.addNode("node1");
ag.addNode("node2");
AbstractNode node1 = ag.getNode("node1");
AbstractNode node2 = ag.getNode("node2");
Edge edge1 = ag.addEdge("edge_1", "node1", "node2", false);
assertEquals(null, ag.removeEdge(null, "node2"));
}
@Test
public void removeEdgeTestFromToIndex() {
AbstractGraph ag = new SingleGraph("graph", false, false);
ag.addNode("node1");
ag.addNode("node2");
AbstractNode node1 = ag.getNode("node1");
AbstractNode node2 = ag.getNode("node2");
Edge edge1 = ag.addEdge("edge_1", "node1", "node2", false);
ag.removeEdge(0, 1);
assertEquals(0, ag.getEdgeCount());
}
@Test
public void removeEdgeTestFromToNode() {
AbstractGraph ag = new SingleGraph("graph", false, false);
ag.addNode("node1");
ag.addNode("node2");
AbstractNode node1 = ag.getNode("node1");
AbstractNode node2 = ag.getNode("node2");
Edge edge1 = ag.addEdge("edge_1", "node1", "node2", false);
ag.removeEdge(node1, node2);
assertEquals(0, ag.getEdgeCount());
}
@Test
public void removeEdgeTestFromToNodeNullStrictChecking() {
AbstractGraph ag = new SingleGraph("graph", true, false);
ag.addNode("node1");
ag.addNode("node2");
AbstractNode node1 = ag.getNode("node1");
AbstractNode node2 = ag.getNode("node2");
// Edge edge1 = ag.addEdge("edge_1", "node1", "node2", false);
try {
ag.removeEdge(node1, node2);
fail("should not remove edge");
} catch (ElementNotFoundException e) {
System.err.println(e.getMessage() + "\n");
}
}
@Test
public void removeEdgeTestFromToNodeNullNoStrictChecking() {
AbstractGraph ag = new SingleGraph("graph", false, false);
ag.addNode("node1");
ag.addNode("node2");
AbstractNode node1 = ag.getNode("node1");
AbstractNode node2 = ag.getNode("node2");
// Edge edge1 = ag.addEdge("edge_1", "node1", "node2", false);
assertEquals(null, ag.removeEdge(node1, node2));
}
// ----------------------------------------------------------------------
/* Add Node tests */
@Test
public void addNodeTestExistenceChecking() {
AbstractGraph ag = new SingleGraph("graph", true, false);
ag.addNode("node1");
try {
ag.addNode("node1");
fail("should not add node");
} catch (IdAlreadyInUseException e) {
System.err.println(e.getMessage() + "\n");
}
}
@Test
public void addNodeTestExistenceNoChecking() {
AbstractGraph ag = new SingleGraph("graph", false, false);
AbstractNode old = ag.addNode("node1");
AbstractNode new_ = ag.addNode("node1");
assertEquals(old, new_);
}
// ----------------------------------------------------------------------
/* Remove Node tests */
@Test
public void removeNodeTestIndexNullStrictChecking() {
AbstractGraph ag = new SingleGraph("graph", true, false);
try {
ag.removeNode(0);
fail("should not remove node");
} catch (ElementNotFoundException e) {
System.err.println(e.getMessage());
}
}
@Test
public void removeNodeTestIndexNullNoStrictChecking() {
AbstractGraph ag = new SingleGraph("graph", false, false);
assertEquals(null, ag.removeNode(0));
}
@Test
public void removeNodeTestNodeNullStrictChecking() {
AbstractGraph ag = new SingleGraph("graph", true, false);
AbstractNode node1 = null;
try {
ag.removeNode(node1);
fail("should not remove node");
} catch (ElementNotFoundException e) {
System.err.println(e.getMessage());
}
}
@Test
public void removeNodeTestNodeNullNoStrictChecking() {
AbstractGraph ag = new SingleGraph("graph", false, false);
AbstractNode node1 = null;
assertEquals(null, ag.removeNode(node1));
}
@Test
public void removeNodeTest() {
AbstractGraph ag = new SingleGraph("graph", true, true);
ag.addNode("node1");
ag.addNode("node2");
AbstractNode node1 = ag.getNode("node1");
AbstractNode node2 = ag.getNode("node2");
ag.removeNode("node1");
assertEquals(1, ag.getNodeCount());
}
@Test
public void removeNodeObjectNotNullTest() {
AbstractGraph ag = new SingleGraph("graph", true, true);
ag.addNode("node1");
ag.addNode("node2");
AbstractNode node1 = ag.getNode("node1");
AbstractNode node2 = ag.getNode("node2");
ag.removeNode(node1);
assertEquals(1, ag.getNodeCount());
}
// ----------------------------------------------------------------------
/* AbstractGraph tests */
@Test
public void getEachNodeTest() {
AbstractGraph ag = new SingleGraph("graph", true, true);
ag.addNode("node1");
Iterator nodeIt = ag.getEachNode().iterator();
ArrayList nodes = new ArrayList();
while (nodeIt.hasNext()) {
nodes.add(nodeIt.next().toString());
}
assertEquals("node1", nodes.get(0));
}
@Test
public void getEachEdgeTest() {
AbstractGraph ag = new SingleGraph("graph", true, true);
ag.addNode("node1");
ag.addNode("node2");
AbstractEdge edge1 = ag.addEdge("edge1", "node1", "node2", false);
Iterator edgeIt = ag.getEachEdge().iterator();
ArrayList edges = new ArrayList();
while (edgeIt.hasNext()) {
edges.add(edgeIt.next().toString());
}
assertEquals("edge1[node1--node2]", edges.get(0));
}
@Test
public void iteratorTest() {
AbstractGraph ag = new SingleGraph("graph", true, true);
ag.addNode("node1");
Iterator<Node> nodeIt = ag.iterator();
ArrayList nodes = new ArrayList();
while (nodeIt.hasNext()) {
nodes.add(nodeIt.next().toString());
}
assertEquals("node1", nodes.get(0));
}
@Test
public void nodeFactoryTest() {
AbstractGraph ag = new SingleGraph("graph", true, true);
NodeFactory nf = ag.nodeFactory();
SingleNode node1 = (SingleNode) nf.newInstance("node1", ag);
assertEquals(1, ag.getNodeCount());
}
@Test
public void edgeFactoryTest() {
AbstractGraph ag = new SingleGraph("graph", true, true);
ag.addNode("node1");
ag.addNode("node2");
AbstractNode node1 = ag.getNode("node1");
AbstractNode node2 = ag.getNode("node2");
EdgeFactory ef = ag.edgeFactory();
AbstractEdge edge1 = (AbstractEdge) ef.newInstance("edge1", node1,
node2, false);
assertEquals(1, ag.getEdgeCount());
}
@Test
public void isStrictTest() {
AbstractGraph ag = new SingleGraph("graph", true, true);
assertTrue(ag.isStrict());
}
@Test
public void isAutoCreationEnabledTest() {
AbstractGraph ag = new SingleGraph("graph", true, true);
assertTrue(ag.isAutoCreationEnabled());
}
@Test
public void setStrictTest(){
AbstractGraph ag = new SingleGraph("graph", true, true);
ag.setStrict(false);
assertFalse(ag.isStrict());
}
@Test
public void setAutoCreateTest(){
AbstractGraph ag = new SingleGraph("graph", true, true);
ag.setAutoCreate(false);
assertFalse(ag.isAutoCreationEnabled());
}
@Test
public void setNullAttributesAreErrorsTest(){
AbstractGraph ag = new SingleGraph("graph", true, true);
ag.setNullAttributesAreErrors(false);
assertFalse(ag.nullAttributesAreErrors());
}
@Test
public void getStepTest(){
AbstractGraph ag = new SingleGraph("graph", true, true);
assertEquals(0.0,ag.getStep(),0.0);
}
@Test
public void stepBeginsTest(){
AbstractGraph ag = new SingleGraph("graph", true, true);
ag.stepBegins(1.0);
assertEquals(1.0, ag.getStep(),1.0);
}
@Test
public void addSinkTest(){
AbstractGraph ag = new SingleGraph("graph", true, true);
Sink s = new SinkAdapter();
ag.addSink(s);
GraphListeners agListeners = ag.listeners;
Iterator listenersIt = agListeners.elementSinks().iterator();
ArrayList listenersList = new ArrayList();
while(listenersIt.hasNext()){
listenersList.add(listenersIt.next());
}
assertEquals(listenersList.get(0),s);
}
@Test
public void edgeAttributeAddedTest(){
AbstractGraph ag = new SingleGraph("graph", true, true);
ag.addNode("node1");
ag.addNode("node2");
AbstractEdge edge1 = ag.addEdge("edge1","node1","node2",false);
// edge1.setAttribute("weight", 8);
// System.out.println(ag.listeners.sinkTime.isNewEvent("graph", 17));
ag.edgeAttributeAdded("graph", 20, "edge1", "weight", 8);
// System.out.println(ag.listeners.sinkTime.isNewEvent("graph", 20));
assertEquals(8,edge1.getAttribute("weight"));
}
@Test
public void edgeAttributeChangedTest(){
AbstractGraph ag = new SingleGraph("graph", true, true);
ag.addNode("node1");
ag.addNode("node2");
AbstractEdge edge1 = ag.addEdge("edge1","node1","node2",false);
ag.edgeAttributeAdded("graph", 1, "edge1", "weight", 8);
ag.edgeAttributeChanged("graph", 20, "edge1", "weight", 8, 12);
assertEquals(12,edge1.getAttribute("weight"));
}
@Test
public void edgeAttributeRemovedTest(){
AbstractGraph ag = new SingleGraph("graph", true, true);
ag.addNode("node1");
ag.addNode("node2");
AbstractEdge edge1 = ag.addEdge("edge1","node1","node2",false);
ag.edgeAttributeAdded("graph", 1, "edge1", "weight", 8);
ag.edgeAttributeRemoved("graph", 19, "edge1", "weight");
assertNull(edge1.getAttribute("weight"));
}
@Test
public void graphAttributeAddedTest(){
AbstractGraph ag = new SingleGraph("graph", true, true);
ag.graphAttributeAdded("graph", 3, "weight", 2);
assertEquals(2,ag.getAttribute("weight"));
}
@Test
public void graphAttributeChangedTest(){
AbstractGraph ag = new SingleGraph("graph", true, true);
ag.graphAttributeAdded("graph", 3, "weight", 2);
ag.graphAttributeChanged("graph", 7, "weight", 2, 6);
assertEquals(6,ag.getAttribute("weight"));
}
@Test
public void graphAttributeRemovedTest(){
AbstractGraph ag = new SingleGraph("graph", true, true);
ag.graphAttributeAdded("graph", 3, "weight", 2);
ag.graphAttributeRemoved("graph", 12, "weight");
assertNull(ag.getAttribute("weight"));
}
@Test
public void nodeAttributeAddedTest(){
AbstractGraph ag = new SingleGraph("graph", true, true);
ag.addNode("node1");
AbstractNode node1 = ag.getNode("node1");
ag.nodeAttributeAdded("graph", 15, "node1", "weight", 9);
assertEquals(9,node1.getAttribute("weight"));
}
@Test
public void nodeAttributeChangedTest(){
AbstractGraph ag = new SingleGraph("graph", true, true);
ag.addNode("node1");
AbstractNode node1 = ag.getNode("node1");
ag.nodeAttributeAdded("graph", 15, "node1", "weight", 9);
ag.nodeAttributeChanged("graph", 21, "node1", "weight", 9, 4);
assertEquals(4,node1.getAttribute("weight"));
}
@Test
public void nodeAttributeRemovedTest(){
AbstractGraph ag = new SingleGraph("graph", true, true);
ag.addNode("node1");
AbstractNode node1 = ag.getNode("node1");
ag.nodeAttributeAdded("graph", 15, "node1", "weight", 9);
ag.nodeAttributeRemoved("graph", 18, "node1", "weight");
assertNull(node1.getAttribute("weight"));
}
@Test
public void edgeAddedTest(){
AbstractGraph ag = new SingleGraph("graph", true, true);
ag.addNode("node1");
ag.addNode("node2");
AbstractNode node1 = ag.getNode("node1");
AbstractNode node2 = ag.getNode("node2");
ag.edgeAdded("graph", 11, "edge1", "node1", "node2", false);
assertEquals(1, ag.getEdgeCount());
}
@Test
public void edgeRemovedTest(){
AbstractGraph ag = new SingleGraph("graph", true, true);
ag.addNode("node1");
ag.addNode("node2");
AbstractNode node1 = ag.getNode("node1");
AbstractNode node2 = ag.getNode("node2");
ag.edgeAdded("graph", 11, "edge1", "node1", "node2", false);
ag.edgeRemoved("graph",17, "edge1");
assertEquals(0, ag.getEdgeCount());
}
@Test
public void graphClearedTest(){
AbstractGraph ag = new SingleGraph("graph", true, true);
ag.addNode("node1");
ag.addNode("node2");
ag.addNode("node3");
ag.addEdge("edge1","node1","node2");
ag.addEdge("edge2","node1","node3");
ag.graphCleared("graph", 14);
assertEquals(0,ag.getNodeCount());
assertEquals(0,ag.getEdgeCount());
}
@Test
public void nodeAddedTest(){
AbstractGraph ag = new SingleGraph("graph", true, true);
ag.nodeAdded("graph", 16, "node1");
assertEquals(1,ag.getNodeCount());
}
@Test
public void nodeRemovedTest(){
AbstractGraph ag = new SingleGraph("graph", true, true);
ag.nodeAdded("graph", 17, "node1");
ag.nodeAdded("graph", 23, "node2");
ag.edgeAdded("graph", 26, "edge1", "node1", "node2", false);
ag.nodeRemoved("graph", 29, "node1");
assertEquals(1,ag.getNodeCount());
}
@Test
public void stepBeginsTest2(){
AbstractGraph ag = new SingleGraph("graph", true, true);
ag.stepBegins("graph", 15, 2.0);
assertEquals(2.0, ag.getStep(),2.0);
}
}