SingleGraphEO1.java

package org.graphstream.graph.implementations;

import static org.junit.Assert.*;
import org.graphstream.graph.Edge;
import org.graphstream.graph.Graph;
import org.graphstream.graph.GraphFactory;
import org.graphstream.graph.Node;
import org.graphstream.graph.implementations.SingleGraph;
import org.junit.BeforeClass;

import org.junit.Test;

public class SingleGraphEO1 {
		
		//TC-SG_C01
		@Test
		public void testEdgeAdition() {
			Graph singleGraph = new SingleGraph("single-graph");
		
			Node root = singleGraph.addNode("root");
			
			Node leftNode = singleGraph.addNode("leftNode");
			Edge RL = singleGraph.addEdge("root-left", "root", "leftNode");
			
			assertEquals(1, singleGraph.getEdgeCount());

			// id returns the correct node
			assertEquals(root, singleGraph.getNode("root"));
			
			// is undirected graph
			assertFalse(RL.isDirected());
			
			// left and right node of the edge RL
			assertEquals(root, RL.getNode0());
			assertEquals(leftNode, RL.getNode1());
			
			// source and target of the edge RL
			assertEquals(root, RL.getSourceNode());
			assertEquals(leftNode, RL.getTargetNode());
		}
		
		//TC-SG_C02
		@Test
		public void testEdgeRemoval() {
			Graph singleGraph = new MultiGraph("single-graph");
			singleGraph.addNode("root");
			singleGraph.addNode("leftNode");
			singleGraph.addNode("rightNode");
			
			singleGraph.addEdge("root-left", "root", "leftNode");
			singleGraph.addEdge("root-right", "root", "rightNode");
			
			singleGraph.removeEdge("root-left");
			
			assertEquals(1, singleGraph.getEdgeCount());
		}
		//TC-SG_C03
		@Test
		public void testAddNode() {
			Graph singleGraph = new SingleGraph("single-graph");
			singleGraph.addNode("root");
			singleGraph.addNode("leftNode");
			singleGraph.addNode("rightNode");
			assertEquals(singleGraph.getNodeCount(), 3);
		}

		//TC-SG_C04
		@Test
		public void testRemoveNode() {
			Graph singleGraph  = new SingleGraph("single-graph");
			singleGraph.addNode("root");
			singleGraph.addNode("leftNode");
			singleGraph.addNode("rightNode");		
			singleGraph.addEdge("root-right", "root", "rightNode");
			singleGraph.addEdge("left-right", "leftNode", "rightNode");
			singleGraph.removeNode("root");
			
			assertEquals(2, singleGraph.getNodeCount());
			assertEquals(1, singleGraph.getEdgeCount());
			
		}
	
		
		private static SingleGraph graph = new SingleGraph("test");
		
		@BeforeClass
		public static void testSetup() {
			Node n1 = graph.addNode("node1");
			Node n2 = graph.addNode("node2");
			
			graph.addEdge("n1-n2", n1, n2);
		  }
		
		//TC-SG_C05
		
		@Test
		public void testSingleGraphBasics() {
			assertNotNull(graph);
			assertEquals("test", graph.getId());
		}

		//TC-SG_C06

		
		@Test
		public void testSingleGraphEdgesBasics(){
			Edge e1 = graph.getEdge("n1-n2");
			
			assertNotNull(e1);
			assertEquals("n1-n2", e1.getId());
			
		}
		
		//TC-SG_C07
		
		@Test
		public void testSingleGraphNodes(){
			
			Node n1 = graph.getNode("node1");
			Node n2 = graph.getNode("node2");
			
			assertNotNull(n1);
			assertNotNull(n2);
			
			assertEquals("node1", n1.getId());
			assertEquals("node2", n2.getId());
		}
		
		//TC-SG_C08
		
		@Test
		public void singleGraphEdgeTest() {
			SingleGraph sg = new SingleGraph("first", false, false, 1, 0);
			sg.addNode("node_1");
			sg.addNode("node_2");
			AbstractNode node1 = sg.getNode("node_1");
			AbstractNode node2 = sg.getNode("node_2");
		
			AbstractEdge edge = new AbstractEdge("edge_1", node1, node2, true);
			
			assertEquals(node1, edge.getSourceNode());
			assertEquals(node2, edge.getTargetNode());
		}
		
		
		//TC-SG_C09
		
		@Test
		public void testSingleGraphEdges1(){
			Node n1 = graph.getNode("node1");
			Node n2 = graph.getNode("node2");
			Edge e1 = graph.getEdge("n1-n2");
			
			assertEquals(n1.getEdgeBetween(n2), e1);
			assertEquals(n2.getEdgeBetween(n1), e1);
			assertEquals(n1.getEdgeBetween(n2), n2.getEdgeBetween(n1));
		}
		
		//TC-SG_C10
		@Test
		public void singleGraphNotConnectedNodeTest() {
			SingleGraph sg = new SingleGraph("first", false, false, 3, 2);
			sg.addNode("node_1");
			sg.addNode("node_2");
			sg.addNode("node_3");
			
			AbstractNode node1 = sg.getNode("node_1");
			
			AbstractNode node2 = sg.getNode("node_2");
			AbstractNode node3 = sg.getNode("node_3");
			
			sg.addEdge("edge_1", node1, node2, true);
			
			assertEquals(0, node3.getDegree());
			}
		
		//TC-SG_C11
		@Test
		public void singleGraphLoopTest() {
			SingleGraph sg = new SingleGraph("first", false, false, 1, 0);
			sg.addNode("node_1");
			
			AbstractNode node1 = sg.getNode("node_1");
			sg.addEdge("edge_1", node1, node1, true);
			AbstractEdge edge = sg.getEdge("edge_1");
			assertEquals(node1, edge.getTargetNode());
		}
		
		
		//TC-SG_C12
		@Test
		public void singleGraphNodeDegreeTest() {
			SingleGraph sg = new SingleGraph("first", false, false, 3, 2);
			sg.addNode("node_1");
			sg.addNode("node_2");
			sg.addNode("node_3");
			
			AbstractNode node1 = sg.getNode("node_1");
			AbstractNode node2 = sg.getNode("node_2");
			AbstractNode node3 = sg.getNode("node_3");
			
			sg.addEdge("edge_1", node1, node2, true);
			sg.addEdge("edge_2", node1, node3, true);
			
			assertEquals(2, node1.getDegree());
		}
		
		//TC-SG_C13
		@Test
		public void singleGraphNotMultiTest() {
			SingleGraph sg = new SingleGraph("first", false, false, 3, 2);
			sg.addNode("node_1");
			sg.addNode("node_2");
			
			AbstractNode node1 = sg.getNode("node_1");
			AbstractNode node2 = sg.getNode("node_2");
			
			sg.addEdge("edge_1", node1, node2, false);
			sg.addEdge("edge_2", node2, node1, false);
			
			AbstractEdge edge1 = sg.getEdge("edge_1");
			AbstractEdge edge2 = sg.getEdge("edge_2");
			
			
			assertFalse(2==node1.getDegree());
			assertNull(edge2);
		}
}