SingleGraphTest.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.Node;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;

public class SingleGraphTest {
	
	private Graph singleGraph;

	@Before
	public void testSetup() {
		singleGraph = new SingleGraph("single-graph");
		Node root = singleGraph.addNode("root");
		Node leftNode = singleGraph.addNode("leftNode");
		Node rightNode = singleGraph.addNode("rightNode");
		Edge RL = singleGraph.addEdge("root-left", "root", "leftNode");
		Edge RR = singleGraph.addEdge("root-right", "root", "rightNode");
	}

	
	//TC-SG_C01
	@Test
	public void EdgeAditionTest() {
		Node root = singleGraph.getNode("root");
		Edge RL = singleGraph.getEdge("root-left");
		Node leftNode = singleGraph.getNode("leftNode");

		assertEquals(2, 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 EdgeRemovalTest() {
		Edge RL = singleGraph.addEdge("right-left", "leftNode", "rightNode");
		assertEquals(3, singleGraph.getEdgeCount());
		singleGraph.removeEdge("right-left");

		assertEquals(2, singleGraph.getEdgeCount());
	}
	//TC-SG_C03
	@Test
	public void AddNodeTest() {
		
		assertEquals(singleGraph.getNodeCount(), 3);
	}

	//TC-SG_C04
	@Test
	public void RemoveNodeTest() {

		singleGraph.removeNode("root");

		assertEquals(2, singleGraph.getNodeCount());
		assertEquals(0, singleGraph.getEdgeCount());

	}
	
	//TC-SG_C05
	@Test
	public void SingleGraphBasicsTest() {
		assertNotNull(singleGraph);
		assertEquals("single-graph", singleGraph.getId());
	}
	
	//TC-SG_C06
	@Test
	public void SingleGraphNodesTest(){
		
		Node n1 = singleGraph.getNode("leftNode");
		Node n2 = singleGraph.getNode("rightNode");
		
		assertNotNull(n1);
		assertNotNull(n2);
		
		assertEquals("leftNode", n1.getId());
		assertEquals("rightNode", n2.getId());
	}
	
	//TC-SG_C07
	@Test
	public void SingleGraphEdgesBasicsTest(){
		Edge e1 = singleGraph.getEdge("root-left");
		
		assertNotNull(e1);
		assertEquals("root-left", e1.getId());
		
	}
	
	//TC-SG_C08
	@Test
	public void SingleGraphEdges1Test(){
		Node n1 = singleGraph.getNode("leftNode");
		Node n2 = singleGraph.getNode("root");
		Edge e1 = singleGraph.getEdge("root-left");
		
		assertEquals(n1.getEdgeBetween(n2), e1);
		assertEquals(n2.getEdgeBetween(n1), e1);
		assertEquals(n1.getEdgeBetween(n2), n2.getEdgeBetween(n1));
	}
	
	//TC-SG_C09
	@Test
	public void SingleGraphEmptyTest() {
		SingleGraph sg = new SingleGraph("empty", false, false, 0, 0);
		assertEquals(0, sg.getNodeCount());
		assertEquals(0, sg.getEdgeCount());
	}
	
	//TC-SG_C10
	@Test
	public void SingleGraphEdgeSourceAndTargetTest() {
		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_C11
	@Test
	public void SingleGraphLoopTest() {
		AbstractNode node1 = singleGraph.getNode("leftNode");
		
		singleGraph.addEdge("edgeLoop", node1, node1, true);
		AbstractEdge edge = singleGraph.getEdge("edgeLoop");
		
		assertEquals(node1, edge.getTargetNode());
		singleGraph.removeEdge("edgeLoop"); //This line is needed in order to not break the test "testEdgeRemoval"
	}
	
	//TC-SG_C12
	@Test
	public void SingleGraphNodeDegreeTest() {
		AbstractNode root = singleGraph.getNode("root");
		assertEquals(2, root.getDegree());
	}
	
	//TC-SG_C13
	@Test
	public void singleGraphNotMultiTestTest() {
		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 edge2 = sg.getEdge("edge_2");
		
		
		assertFalse(node1.getDegree() == 2);
		assertNull(edge2);
	}
}