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