CategoryPartitionRemoveEdgeSingleGraph.java

package org.graphstream.graph.implementations;

import static org.junit.Assert.assertEquals;

import org.databene.benerator.anno.Source;
import org.databene.feed4junit.Feeder;
import org.graphstream.graph.Edge;
import org.graphstream.graph.ElementNotFoundException;
import org.graphstream.graph.implementations.AbstractEdge;
import org.graphstream.graph.implementations.AbstractNode;
import org.graphstream.graph.implementations.SingleGraph;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import org.junit.runner.RunWith;

import sun.org.mozilla.javascript.internal.Node;

//@RunWith(Feeder.class)
public class CategoryPartitionRemoveEdgeSingleGraph {


	@Rule
	public ExpectedException exception = ExpectedException.none();

	//IDEDGEEX,EdgeExSorceTarget,SourceNodeEx,TargetNodeEx,TypEdge,StrickChecking,SourceTargetInverted

	//	@Test
	//	@Source("csvFiles/CategoryPartitionRemoveEdgeSingleGraph.csv")
	//	public void testRemoveEdge(Boolean idEdgeExistnce, Boolean edgeExBetweenSorceTarget, String typEdge, Boolean sourceNodeEx, 
	//			Boolean targetNodeEx, Boolean sourceTargetInverted, Boolean strickChecking, Boolean differentGraph) {
	//		
	//		if (idEdgeExistnce && edgeExBetweenSorceTarget && typEdge.equals("directed") && sourceNodeEx && targetNodeEx && sourceTargetInverted &&
	//				strickChecking && differentGraph) {
	//			test1();
	//			test2();
	//		}
	//	}

	// [ 1 ]/////////////////////////////////////////////////////////////////////////////////////////////////////////////
	///////////        True,True,directed,True,True,True,True,True  //////////////////////////////////////////////
	//////////////////////////////////////////////////////////////////////////////////////////////////////////////	


	/**
	 * removeEdge(Edge edge)
	 */
	@Test
	public void CatOnetest1() {
		SingleGraph s1 = new SingleGraph("SingleGraph1", true, true);
		SingleGraph s2 = new SingleGraph("SingleGraph2", true, true);

		s1.addNode("S1Node1");
		s1.addNode("S1Node2");
		s1.addEdge("EdgeS1", "S1Node1", "S1Node2", true);

		s2.addNode("S2Node1");
		s2.addNode("S2Node2");
		s2.addEdge("EdgeS2", "S2Node1", "S2Node2", true);

		Edge e = s2.getEdge("EdgeS2");

		s1.removeEdge(e);
		assertEquals(1, s1.getEdgeCount());

		assertEquals(1, s2.getEdgeCount());
	}

	/**
	 * removeEdge(java.lang.String id)
	 */
	@Test
	public void CatOnetest2() {
		SingleGraph s1 = new SingleGraph("SingleGraph1", true, true);
		SingleGraph s2 = new SingleGraph("SingleGraph2", true, true);

		s1.addNode("S1Node1");
		s1.addNode("S1Node2");
		s1.addEdge("EdgeS1", "S1Node1", "S1Node2", true);

		s2.addNode("S2Node1");
		s2.addNode("S2Node2");
		s2.addEdge("EdgeS2", "S2Node1", "S2Node2", true);

		Edge e = s2.getEdge("EdgeS2"); 

		exception.expect(ElementNotFoundException.class);
		s1.removeEdge("EdgeS2");

	}


	/**
	 * protected void removeEdge(AbstractEdge edge,
	 *         boolean graphCallback,
	 *         boolean sourceCallback,
	 *         boolean targetCallback)
	 * All input false
	 */
	@Test
	public void CatOnetest3() {
		SingleGraph s1 = new SingleGraph("SingleGraph1", true, true);
		SingleGraph s2 = new SingleGraph("SingleGraph2", true, true);

		s1.addNode("S1Node1");
		s1.addNode("S1Node2");
		s1.addEdge("EdgeS1", "S1Node1", "S1Node2", true);

		s2.addNode("S2Node1");
		s2.addNode("S2Node2");
		s2.addEdge("EdgeS2", "S2Node1", "S2Node2", true);

		AbstractEdge e = s2.getEdge("EdgeS2");

		s1.removeEdge(e, false, false, false);
		assertEquals(1, s1.getEdgeCount());
		assertEquals(1, s2.getEdgeCount());

	}

	/**
	 * protected void removeEdge(AbstractEdge edge,
	 *         boolean graphCallback,
	 *         boolean sourceCallback,
	 *         boolean targetCallback)
	 *         
	 * All input true
	 */
	@Test
	public void CatOnetest4() {
		SingleGraph s1 = new SingleGraph("SingleGraph1", true, true);
		SingleGraph s2 = new SingleGraph("SingleGraph2", true, true);

		s1.addNode("S1Node1");
		s1.addNode("S1Node2");
		s1.addEdge("EdgeS1", "S1Node1", "S1Node2", true);

		s2.addNode("S2Node1");
		s2.addNode("S2Node2");
		s2.addEdge("EdgeS2", "S2Node1", "S2Node2", true);

		AbstractEdge e = s2.getEdge("EdgeS2");
		s1.removeEdge(e, true, true, true);
		assertEquals(1, s2.getEdgeCount());
		assertEquals(1, s1.getEdgeCount());
	}

	/**
	 * removeEdge(int index)
	 */
	@Test
	public void CatOnetest5() {
		SingleGraph s1 = new SingleGraph("SingleGraph1", true, true);
		SingleGraph s2 = new SingleGraph("SingleGraph2", true, true);

		s1.addNode("S1Node1");
		s1.addNode("S1Node2");
		s1.addEdge("EdgeS1", "S1Node1", "S1Node2", true);

		s2.addNode("S2Node1");
		s2.addNode("S2Node2");
		s2.addEdge("EdgeS2", "S2Node1", "S2Node2", true);

		AbstractEdge e = s2.getEdge("EdgeS2");
		AbstractEdge e2 = s1.getEdge("EdgeS1");
		int id = e.getIndex();
		s1.removeEdge(id);
		assertEquals(1, s2.getEdgeCount());
		assertEquals(1, s1.getEdgeCount());
	}

	/**
	 * removeEdge(int fromIndex, int toIndex)
	 */
	@Test
	public void CatOnetest6() {
		SingleGraph s1 = new SingleGraph("SingleGraph1", true, true);
		SingleGraph s2 = new SingleGraph("SingleGraph2", true, true);

		s1.addNode("S1Node1");
		s1.addNode("S1Node2");
		s1.addEdge("EdgeS1", "S1Node1", "S1Node2", true);

		s2.addNode("S2Node1");
		s2.addNode("S2Node2");
		s2.addEdge("EdgeS2", "S2Node1", "S2Node2", true);

		AbstractNode node1 = s2.getNode("S2Node1");
		AbstractNode node2 = s2.getNode("S2Node2");
		int node1ID = node1.getIndex();
		int node2ID = node2.getIndex();

		s1.removeEdge(node1ID, node2ID);
		assertEquals(1, s2.getEdgeCount());
		assertEquals(1, s1.getEdgeCount());
	}

	/**
	 * removeEdge(Node node1, Node node2)
	 */
	@Test
	public void CatOnetest7() {
		SingleGraph s1 = new SingleGraph("SingleGraph1", true, true);
		SingleGraph s2 = new SingleGraph("SingleGraph2", true, true);

		s1.addNode("S1Node1");
		s1.addNode("S1Node2");
		s1.addEdge("EdgeS1", "S1Node1", "S1Node2", true);

		s2.addNode("S2Node1");
		s2.addNode("S2Node2");
		s2.addEdge("EdgeS2", "S2Node1", "S2Node2", true);

		AbstractNode node1 = s2.getNode("S2Node1");
		AbstractNode node2 = s2.getNode("S2Node2");


		s1.removeEdge(node1, node2);
		assertEquals(1, s2.getEdgeCount());
		assertEquals(1, s1.getEdgeCount());
	}

	/**
	 * removeEdge(java.lang.String from, java.lang.String to)
	 */
	@Test
	public void CatOnetest8() {
		SingleGraph s1 = new SingleGraph("SingleGraph1", true, true);
		SingleGraph s2 = new SingleGraph("SingleGraph2", true, true);

		s1.addNode("S1Node1");
		s1.addNode("S1Node2");
		s1.addEdge("EdgeS1", "S1Node1", "S1Node2", true);

		s2.addNode("S2Node1");
		s2.addNode("S2Node2");
		s2.addEdge("EdgeS2", "S2Node1", "S2Node2", true);

		exception.expect(NullPointerException.class);
		s1.removeEdge("S1Node1", "S2Node2");
		assertEquals(1, s2.getEdgeCount());
		assertEquals(1, s1.getEdgeCount());
	}

	// [ 2 ]///////////////////////////////////////////////////////////////////////////////////////////////////////////
	//IDEDGEEX,EdgeExBetweenSorceTarget,TypEdge,SourceNodeEx,TargetNodeEx,SourceTargetInverted,StrickChecking,differentGraph
	///////////        False,False,notDefined,True,False,False,False,True  //////////////////////////////////////////////
	//////////////////////////////////////////////////////////////////////////////////////////////////////////////


	/**
	 * removeEdge(int fromIndex, int toIndex)
	 */
	@Test
	public void CatTwotest1() {
		SingleGraph s1 = new SingleGraph("SingleGraph1");
		SingleGraph s2 = new SingleGraph("SingleGraph2");
		s1.addNode("S1Node1");
		int id = s1.getNode("S1Node1").getIndex();
		exception.expect(IndexOutOfBoundsException.class);
		s2.removeEdge(id, 5);
	}

	/**
	 * removeEdge(Node node1, Node node2)
	 */
	@Test
	public void CatTwotest2() {
		SingleGraph s1 = new SingleGraph("SingleGraph1");
		SingleGraph s2 = new SingleGraph("SingleGraph2");
		s1.addNode("S1Node1");
		AbstractNode n1 = s1.getNode("S1Node1");

		exception.expect(NullPointerException.class);
		s2.removeEdge(n1, null);
	} 

	/**
	 * removeEdge(java.lang.String from, java.lang.String to)
	 */
	@Test
	public void CatTwotest3() {
		SingleGraph s1 = new SingleGraph("SingleGraph1", true, false);
		SingleGraph s2 = new SingleGraph("SingleGraph2", true, false);
		s1.addNode("S1Node1");

		exception.expect(ElementNotFoundException.class);
		s1.removeEdge("S1Node1", "");
	}

	// [ 3 ]///////////////////////////////////////////////////////////////////////////////////////////////////////////
	//IDEDGEEX,EdgeExBetweenSorceTarget,TypEdge,SourceNodeEx,TargetNodeEx,SourceTargetInverted,StrickChecking,differentGraph
	///////////        True,True,indirected,True,True,False,True,False  //////////////////////////////////////////////
	//////////////////////////////////////////////////////////////////////////////////////////////////////////////
	/**
	 * removeEdge(Edge edge)
	 */
	@Test
	public void CatThreetest1() {
		SingleGraph s1 = new SingleGraph("SingleGraph1", true, true);
		s1.addNode("S1Node1");
		s1.addNode("S1Node2");
		s1.addEdge("EdgeS1", "S1Node1", "S1Node2");

		Edge e = s1.getEdge("EdgeS1");

		s1.removeEdge(e);
		assertEquals(0, s1.getEdgeCount()); 

	}

	/**
	 * removeEdge(java.lang.String id)
	 */
	@Test
	public void CatThreetest2() {
		SingleGraph s1 = new SingleGraph("SingleGraph1", true, true);
		s1.addNode("S1Node1");
		s1.addNode("S1Node2");
		s1.addEdge("EdgeS1", "S1Node1", "S1Node2");

		s1.removeEdge("EdgeS1");
		assertEquals(0, s1.getEdgeCount());


	}


	/**
	 * protected void removeEdge(AbstractEdge edge,
	 *         boolean graphCallback,
	 *         boolean sourceCallback,
	 *         boolean targetCallback)
	 * All input false
	 */
	@Test
	public void CatThreetest3() {
		SingleGraph s1 = new SingleGraph("SingleGraph1", true, true);
		s1.addNode("S1Node1");
		s1.addNode("S1Node2");
		s1.addEdge("EdgeS1", "S1Node1", "S1Node2");

		AbstractEdge e = s1.getEdge("EdgeS1");

		s1.removeEdge(e, false, false, false);
		assertEquals(0, s1.getEdgeCount());
	}

	/**
	 * protected void removeEdge(AbstractEdge edge,
	 *         boolean graphCallback,
	 *         boolean sourceCallback,
	 *         boolean targetCallback)
	 *         
	 * All input true
	 */
	@Test
	public void CatThreetest4() {
		SingleGraph s1 = new SingleGraph("SingleGraph1", true, true);
		s1.addNode("S1Node1");
		s1.addNode("S1Node2");
		s1.addEdge("EdgeS1", "S1Node1", "S1Node2");

		AbstractEdge e = s1.getEdge("EdgeS1");

		s1.removeEdge(e, true, true, true);
		assertEquals(0, s1.getEdgeCount());

	}

	/**
	 * removeEdge(int index)
	 */
	@Test
	public void CatThreetest5() {
		SingleGraph s1 = new SingleGraph("SingleGraph1", true, true);
		s1.addNode("S1Node1");
		s1.addNode("S1Node2");
		s1.addEdge("EdgeS1", "S1Node1", "S1Node2");

		AbstractEdge e = s1.getEdge("EdgeS1");
		int id = e.getIndex();
		s1.removeEdge(id);
		assertEquals(0, s1.getEdgeCount());
	}

	/**
	 * removeEdge(int fromIndex, int toIndex)
	 */
	@Test
	public void CatThreetest6() {
		SingleGraph s1 = new SingleGraph("SingleGraph1", true, true);
		s1.addNode("S1Node1");
		s1.addNode("S1Node2");
		s1.addEdge("EdgeS1", "S1Node1", "S1Node2");

		AbstractNode n1 = s1.getNode("S1Node1");
		AbstractNode n2 = s1.getNode("S1Node2");
		int id1 = n1.getIndex();
		int id2 = n2.getIndex();

		s1.removeEdge(id1, id2);
		assertEquals(0, s1.getEdgeCount());
	}

	/**
	 * removeEdge(Node node1, Node node2)
	 */
	@Test
	public void CatThreetest7() {
		SingleGraph s1 = new SingleGraph("SingleGraph1", true, true);
		s1.addNode("S1Node1");
		s1.addNode("S1Node2");
		s1.addEdge("EdgeS1", "S1Node1", "S1Node2");

		AbstractNode n1 = s1.getNode("S1Node1");
		AbstractNode n2 = s1.getNode("S1Node2");


		s1.removeEdge(n1, n2);
		assertEquals(0, s1.getEdgeCount());
	}

	/**
	 * removeEdge(java.lang.String from, java.lang.String to)
	 */
	@Test
	public void CatThreetest8() {
		SingleGraph s1 = new SingleGraph("SingleGraph1", true, true);
		s1.addNode("S1Node1");
		s1.addNode("S1Node2");
		s1.addEdge("EdgeS1", "S1Node1", "S1Node2");

		s1.removeEdge("S1Node1", "S1Node2");
		assertEquals(0, s1.getEdgeCount());
	}

	// [ 4 ]//////////////////////////////////////////////////////////////////////////////////////////////////////////
	//IDEDGEEX,EdgeExBetweenSorceTarget,TypEdge,SourceNodeEx,TargetNodeEx,SourceTargetInverted,StrickChecking,differentGraph
	///////////        True,True,indirected,True,True,False,False,True //////////////////////////////////////////////
	//////////////////////////////////////////////////////////////////////////////////////////////////////////////

	/**
	 * removeEdge(Edge edge)
	 */
	@Test
	public void CatFourtest1() {
		SingleGraph s1 = new SingleGraph("SingleGraph1");
		SingleGraph s2 = new SingleGraph("SingleGraph2");

		s1.addNode("S1Node1");
		s1.addNode("S1Node2");
		s1.addEdge("EdgeS1", "S1Node1", "S1Node2");

		s2.addNode("S2Node1");
		s2.addNode("S2Node2");
		s2.addEdge("EdgeS2", "S2Node1", "S2Node2");

		Edge e = s2.getEdge("EdgeS2");

		s1.removeEdge(e);
		assertEquals(1, s1.getEdgeCount());
		assertEquals(1, s2.getEdgeCount());
	}

	/**
	 * removeEdge(java.lang.String id)
	 */
	@Test
	public void CatFourtest2() {
		SingleGraph s1 = new SingleGraph("SingleGraph1");
		SingleGraph s2 = new SingleGraph("SingleGraph2");

		s1.addNode("S1Node1");
		s1.addNode("S1Node2");
		s1.addEdge("EdgeS1", "S1Node1", "S1Node2");

		s2.addNode("S2Node1");
		s2.addNode("S2Node2");
		s2.addEdge("EdgeS2", "S2Node1", "S2Node2");

		exception.expect(ElementNotFoundException.class);
		s1.removeEdge("EdgeS2");

	}


	/**
	 * protected void removeEdge(AbstractEdge edge,
	 *         boolean graphCallback,
	 *         boolean sourceCallback,
	 *         boolean targetCallback)
	 * All input false
	 */
	@Test
	public void CatFourtest3() {
		SingleGraph s1 = new SingleGraph("SingleGraph1");
		SingleGraph s2 = new SingleGraph("SingleGraph2");

		s1.addNode("S1Node1");
		s1.addNode("S1Node2");
		s1.addEdge("EdgeS1", "S1Node1", "S1Node2");

		s2.addNode("S2Node1");
		s2.addNode("S2Node2");
		s2.addEdge("EdgeS2", "S2Node1", "S2Node2");

		AbstractEdge e = s2.getEdge("EdgeS2");

		s1.removeEdge(e, false, false, false);
		assertEquals(1, s1.getEdgeCount());
		assertEquals(1, s2.getEdgeCount());

	}

	/**
	 * protected void removeEdge(AbstractEdge edge,
	 *         boolean graphCallback,
	 *         boolean sourceCallback,
	 *         boolean targetCallback)
	 *         
	 * All input true
	 */
	@Test
	public void CatFourtest4() {
		SingleGraph s1 = new SingleGraph("SingleGraph1");
		SingleGraph s2 = new SingleGraph("SingleGraph2");

		s1.addNode("S1Node1");
		s1.addNode("S1Node2");
		s1.addEdge("EdgeS1", "S1Node1", "S1Node2");

		s2.addNode("S2Node1");
		s2.addNode("S2Node2");
		s2.addEdge("EdgeS2", "S2Node1", "S2Node2");

		AbstractEdge e = s2.getEdge("EdgeS2");
		s1.removeEdge(e, true, true, true);
		assertEquals(1, s2.getEdgeCount());
		assertEquals(1, s1.getEdgeCount());
	}

	/**
	 * removeEdge(int index)
	 */
	@Test
	public void CatFourtest5() {
		SingleGraph s1 = new SingleGraph("SingleGraph1");
		SingleGraph s2 = new SingleGraph("SingleGraph2");

		s1.addNode("S1Node1");
		s1.addNode("S1Node2");
		s1.addEdge("EdgeS1", "S1Node1", "S1Node2");

		s2.addNode("S2Node1");
		s2.addNode("S2Node2");
		s2.addEdge("EdgeS2", "S2Node1", "S2Node2");

		AbstractEdge e = s2.getEdge("EdgeS2");
		AbstractEdge e2 = s1.getEdge("EdgeS1");
		int id = e.getIndex();
		s1.removeEdge(id);
		assertEquals(1, s2.getEdgeCount());
		assertEquals(1, s1.getEdgeCount());
	}

	/**
	 * removeEdge(int fromIndex, int toIndex)
	 */
	@Test
	public void CatFourtest6() {
		SingleGraph s1 = new SingleGraph("SingleGraph1");
		SingleGraph s2 = new SingleGraph("SingleGraph2");

		s1.addNode("S1Node1");
		s1.addNode("S1Node2");
		s1.addEdge("EdgeS1", "S1Node1", "S1Node2");

		s2.addNode("S2Node1");
		s2.addNode("S2Node2");
		s2.addEdge("EdgeS2", "S2Node1", "S2Node2");

		AbstractNode node1 = s2.getNode("S2Node1");
		AbstractNode node2 = s2.getNode("S2Node2");
		int node1ID = node1.getIndex();
		int node2ID = node2.getIndex();

		s1.removeEdge(node1ID, node2ID);
		assertEquals(1, s2.getEdgeCount());
		assertEquals(1, s1.getEdgeCount());
	}

	/**
	 * removeEdge(Node node1, Node node2)
	 */
	@Test
	public void CatFourtest7() {
		SingleGraph s1 = new SingleGraph("SingleGraph1");
		SingleGraph s2 = new SingleGraph("SingleGraph2");

		s1.addNode("S1Node1");
		s1.addNode("S1Node2");
		s1.addEdge("EdgeS1", "S1Node1", "S1Node2");

		s2.addNode("S2Node1");
		s2.addNode("S2Node2");
		s2.addEdge("EdgeS2", "S2Node1", "S2Node2");

		AbstractNode node1 = s2.getNode("S2Node1");
		AbstractNode node2 = s2.getNode("S2Node2");


		s1.removeEdge(node1, node2);
		assertEquals(1, s2.getEdgeCount());
		assertEquals(1, s1.getEdgeCount());
	}

	/**
	 * removeEdge(java.lang.String from, java.lang.String to)
	 */
	@Test
	public void CatFourtest8() {
		SingleGraph s1 = new SingleGraph("SingleGraph1");
		SingleGraph s2 = new SingleGraph("SingleGraph2");

		s1.addNode("S1Node1");
		s1.addNode("S1Node2");
		s1.addEdge("EdgeS1", "S1Node1", "S1Node2");

		s2.addNode("S2Node1");
		s2.addNode("S2Node2");
		s2.addEdge("EdgeS2", "S2Node1", "S2Node2");

		exception.expect(NullPointerException.class);
		s1.removeEdge("S1Node1", "S2Node2");
		assertEquals(1, s2.getEdgeCount());
		assertEquals(1, s1.getEdgeCount());
	}


	// [ 5 ]//////////////////////////////////////////////////////////////////////////////////////////////////////////
	//IDEDGEEX,EdgeExBetweenSorceTarget,TypEdge,SourceNodeEx,TargetNodeEx,SourceTargetInverted,StrickChecking,differentGraph
	///////////        True,false,indirected,True,True,False,False,false //////////////////////////////////////////////
	//////////////////////////////////////////////////////////////////////////////////////////////////////////////


	/**
	 * removeEdge(int fromIndex, int toIndex)
	 */
	@Test
	public void CatFifthtest1() {
		SingleGraph s1 = new SingleGraph("SingleGraph1");

		s1.addNode("S1Node1");
		s1.addNode("S1Node2");

		AbstractNode node1 = s1.getNode("S1Node1");
		AbstractNode node2 = s1.getNode("S1Node2");
		int node1ID = node1.getIndex();
		int node2ID = node2.getIndex();

		exception.expect(ElementNotFoundException.class);
		s1.removeEdge(node1ID, node2ID);

	}

	/**
	 * removeEdge(Node node1, Node node2)
	 */
	@Test
	public void CatFifthtest2() {
		SingleGraph s1 = new SingleGraph("SingleGraph1");

		s1.addNode("S1Node1");
		s1.addNode("S1Node2");

		AbstractNode node1 = s1.getNode("S1Node1");
		AbstractNode node2 = s1.getNode("S1Node2");

		exception.expect(ElementNotFoundException.class);
		s1.removeEdge(node1, node2);

	}

	/**
	 * removeEdge(java.lang.String from, java.lang.String to)
	 */
	@Test
	public void CatFifthtest3() {
		SingleGraph s1 = new SingleGraph("SingleGraph1");

		s1.addNode("S1Node1");
		s1.addNode("S1Node2");


		exception.expect(ElementNotFoundException.class);
		s1.removeEdge("S1Node1", "S1Node2");
	}

	// [ 6 ]//////////////////////////////////////////////////////////////////////////////////////////////////////////
	//IDEDGEEX,EdgeExBetweenSorceTarget,TypEdge,SourceNodeEx,TargetNodeEx,SourceTargetInverted,StrickChecking,differentGraph
	///////////        True,false,indirected,false,True,False,False,false //////////////////////////////////////////////
	//////////////////////////////////////////////////////////////////////////////////////////////////////////////


	/**
	 * removeEdge(int fromIndex, int toIndex)
	 */
	@Test
	public void CatSixthtest1() {
		SingleGraph s1 = new SingleGraph("SingleGraph1");

		s1.addNode("S1Node1");
		s1.addNode("S1Node2");

		AbstractNode node1 = s1.getNode("S1Node1");
		AbstractNode node2 = s1.getNode("S1Node2");
		int node1ID = node1.getIndex();
		int node2ID = node2.getIndex();

		exception.expect(ElementNotFoundException.class);
		s1.removeEdge(node1ID, node2ID);

	}

	/**
	 * removeEdge(Node node1, Node node2)
	 */
	@Test
	public void CatSixthtest2() {
		SingleGraph s1 = new SingleGraph("SingleGraph1");

		s1.addNode("S1Node1");
		s1.addNode("S1Node2");

		AbstractNode node1 = s1.getNode("S1Node1");
		AbstractNode node2 = s1.getNode("S1Node2");

		exception.expect(ElementNotFoundException.class);
		s1.removeEdge(node1, node2);

	}

	/**
	 * removeEdge(java.lang.String from, java.lang.String to)
	 */
	@Test
	public void CatSixthtest3() {
		SingleGraph s1 = new SingleGraph("SingleGraph1");
		s1.addNode("S1Node2");

		exception.expect(ElementNotFoundException.class);
		s1.removeEdge("", "S1Node2");
	}


	// [ 7 ]///////////////////////////////////////////////////////////////////////////////////////////////////////////
	//IDEDGEEX,EdgeExBetweenSorceTarget,TypEdge,SourceNodeEx,TargetNodeEx,SourceTargetInverted,StrickChecking,differentGraph
	///////////        True,True,indirected,false,True,False,True,False  //////////////////////////////////////////////
	//////////////////////////////////////////////////////////////////////////////////////////////////////////////

	/**
	 * removeEdge(int fromIndex, int toIndex)
	 */
	@Test
	public void CatSeventhtest6() {
		SingleGraph s1 = new SingleGraph("SingleGraph1", true, true);
		s1.addNode("S1Node1");
		s1.addNode("S1Node2");
		s1.addEdge("EdgeS1", "S1Node1", "S1Node2");

		AbstractNode n1 = s1.getNode("S1Node1");
		AbstractNode n2 = s1.getNode("S1Node2");
		int id1 = n1.getIndex();
		int id2 = n2.getIndex();

		exception.expect(ElementNotFoundException.class);
		s1.removeEdge(1, id2);

	}

	/**
	 * removeEdge(Node node1, Node node2)
	 */
	@Test
	public void CatSeventhtest7() {
		SingleGraph s1 = new SingleGraph("SingleGraph1", true, true);
		s1.addNode("S1Node1");
		s1.addNode("S1Node2");
		s1.addEdge("EdgeS1", "S1Node1", "S1Node2");

		AbstractNode n1 = s1.getNode("S1Node1");
		AbstractNode n2 = s1.getNode("S1Node2");


		s1.removeEdge(n1, n2);
		assertEquals(0, s1.getEdgeCount());
	}

	/**
	 * removeEdge(java.lang.String from, java.lang.String to)
	 */
	@Test
	public void CatSeventhtest8() {
		SingleGraph s1 = new SingleGraph("SingleGraph1", true, true);
		s1.addNode("S1Node1");
		s1.addNode("S1Node2");
		s1.addEdge("EdgeS1", "S1Node1", "S1Node2");

		s1.removeEdge("S1Node1", "S1Node2");
		assertEquals(0, s1.getEdgeCount());
	}

}