DhnsTestDirectedGraph.java

/*
Copyright 2008-2010 Gephi
Authors : Mathieu Bastian <mathieu.bastian@gephi.org>
Website : http://www.gephi.org

This file is part of Gephi.

DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

Copyright 2011 Gephi Consortium. All rights reserved.

The contents of this file are subject to the terms of either the GNU
General Public License Version 3 only ("GPL") or the Common
Development and Distribution License("CDDL") (collectively, the
"License"). You may not use this file except in compliance with the
License. You can obtain a copy of the License at
http://gephi.org/about/legal/license-notice/
or /cddl-1.0.txt and /gpl-3.0.txt. See the License for the
specific language governing permissions and limitations under the
License.  When distributing the software, include this License Header
Notice in each file and include the License files at
/cddl-1.0.txt and /gpl-3.0.txt. If applicable, add the following below the
License Header, with the fields enclosed by brackets [] replaced by
your own identifying information:
"Portions Copyrighted [year] [name of copyright owner]"

If you wish your version of this file to be governed by only the CDDL
or only the GPL Version 3, indicate your decision by adding
"[Contributor] elects to include this software in this distribution
under the [CDDL or GPL Version 3] license." If you do not indicate a
single choice of license, a recipient has the option to distribute
your version of this file under either the CDDL, the GPL Version 3 or
to extend the choice of license to its licensees as provided above.
However, if you add GPL Version 3 code and therefore, elected the GPL
Version 3 license, then the option applies only if the new code is
made subject to such option by the copyright holder.

Contributor(s):

Portions Copyrighted 2011 Gephi Consortium.
*/
package org.gephi.graph.dhns.core;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.gephi.graph.api.Edge;
import org.gephi.graph.api.Node;
import org.gephi.graph.dhns.DhnsGraphController;
import org.gephi.graph.dhns.edge.AbstractEdge;
import org.gephi.graph.dhns.graph.HierarchicalDirectedGraphImpl;
import org.gephi.graph.dhns.node.AbstractNode;
import org.gephi.graph.dhns.node.iterators.TreeListIterator;
import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import static org.junit.Assert.*;

/**
 *
 * @author Mathieu Bastian
 */
public class DhnsTestDirectedGraph {

    private Dhns dhnsGlobal;
    private HierarchicalDirectedGraphImpl graphGlobal;
    private Map<String, Node> nodeMap;
    private Map<String, Edge> edgeMap;

    public DhnsTestDirectedGraph() {
    }

    @BeforeClass
    public static void setUpClass() throws Exception {
    }

    @AfterClass
    public static void tearDownClass() throws Exception {
    }

    @Before
    public void setUp() {
        DhnsGraphController controller = new DhnsGraphController();
        dhnsGlobal = new Dhns(controller, null);
        graphGlobal = new HierarchicalDirectedGraphImpl(dhnsGlobal, dhnsGlobal.getGraphStructure().getMainView());
        nodeMap = new HashMap<String, Node>();
        edgeMap = new HashMap<String, Edge>();

        TreeStructure treeStructure = dhnsGlobal.getGraphStructure().getMainView().getStructure();
        GraphFactoryImpl factory = dhnsGlobal.factory();

        //Nodes
        //System.out.println("-----Global-----");
        for (int i = 0; i < 10; i++) {
            Node node = factory.newNode();
            node.getNodeData().setLabel("Node " + i);
            graphGlobal.addNode(node);
            nodeMap.put(node.getNodeData().getLabel(), node);
            //System.out.println("Node " + i + " added. Id = " + node.getId());
        }
        //System.out.println("---End Global---");

        //Alone node
        Node fakeNode1 = factory.newNode();
        Node fakeNode2 = factory.newNode();
        nodeMap.put("Fake Node 1", fakeNode1);
        nodeMap.put("Fake Node 2", fakeNode2);

        //Edges
        Node node1 = nodeMap.get("Node 1");
        Node node2 = nodeMap.get("Node 2");
        Node node3 = nodeMap.get("Node 3");
        Node node4 = nodeMap.get("Node 4");
        Node node5 = nodeMap.get("Node 5");
        Node node6 = nodeMap.get("Node 6");
        Node node7 = nodeMap.get("Node 7");
        Node node8 = nodeMap.get("Node 8");

        AbstractEdge edge1 = factory.newEdge(node4, node5);
        AbstractEdge edge2 = factory.newEdge(node5, node6);
        AbstractEdge edge3 = factory.newEdge(node6, node5);
        AbstractEdge edge4 = factory.newEdge(node7, node7);
        AbstractEdge edge5 = factory.newEdge(node4, node4);

        graphGlobal.addEdge(edge1);
        graphGlobal.addEdge(edge2);
        graphGlobal.addEdge(edge3);
        graphGlobal.addEdge(edge4);
        graphGlobal.addEdge(edge5);

        edgeMap.put("4-5", edge1);
        edgeMap.put("5-6", edge2);
        edgeMap.put("6-5", edge3);
        edgeMap.put("7-7", edge4);
        edgeMap.put("4-4", edge5);
    }

    @After
    public void tearDown() {
        nodeMap.clear();
        dhnsGlobal = null;
        graphGlobal = null;
    }

    @Test
    public void testTreeList() {
        DurableTreeList durableTreeList = new DurableTreeList(null);
        List<AbstractNode> expected = new ArrayList<AbstractNode>();
        for (int i = 0; i < 10; i++) {
            AbstractNode node = new AbstractNode(i, 0, 0, 0, 0, null);
            expected.add(node);
            durableTreeList.add(node);
        }

        TreeListIterator treeListIterator = new TreeListIterator(durableTreeList);
        for (; treeListIterator.hasNext();) {
            AbstractNode node = treeListIterator.next();
            if (node.getId() == 4) {
                treeListIterator.remove();
            }
        }

        //Expected array
        List<AbstractNode> expected1 = new ArrayList<AbstractNode>();
        List<AbstractNode> actual = new ArrayList<AbstractNode>();
        for (int i = 0; i < durableTreeList.size; i++) {
            AbstractNode node = durableTreeList.get(i);
            actual.add(node);
        }
        expected1.addAll(expected);
        expected1.remove(4);
        assertArrayEquals(expected1.toArray(), actual.toArray());

        durableTreeList.remove(2);

        //Expected array
        List<AbstractNode> expected2 = new ArrayList<AbstractNode>();
        actual = new ArrayList<AbstractNode>();
        for (int i = 0; i < durableTreeList.size; i++) {
            AbstractNode node = durableTreeList.get(i);
            actual.add(node);
        }
        expected2.addAll(expected);
        expected2.remove(4);
        expected2.remove(2);
        assertArrayEquals(expected2.toArray(), actual.toArray());

        treeListIterator = new TreeListIterator(durableTreeList);
        for (; treeListIterator.hasNext();) {
            AbstractNode node = treeListIterator.next();
            if (node.getId() == 5) {
                treeListIterator.remove();
            }
        }

        durableTreeList.remove(5);

        //Expected array
        List<AbstractNode> expected3 = new ArrayList<AbstractNode>();
        actual = new ArrayList<AbstractNode>();
        for (int i = 0; i < durableTreeList.size; i++) {
            AbstractNode node = durableTreeList.get(i);
            actual.add(node);
        }
        expected3.addAll(expected);
        expected3.remove(4);
        expected3.remove(2);
        expected3.remove(3);
        expected3.remove(5);
        assertArrayEquals(expected3.toArray(), actual.toArray());
    }

    @Test
    public void testAddNode() {
        System.out.println("testAddNode");
        DhnsGraphController controller = new DhnsGraphController();
        Dhns dhns = new Dhns(controller, null);
        HierarchicalDirectedGraphImpl graph = new HierarchicalDirectedGraphImpl(dhns, dhns.getGraphStructure().getMainView());
        TreeStructure treeStructure = dhns.getGraphStructure().getMainView().getStructure();
        GraphFactoryImpl factory = dhns.factory();

        for (int i = 0; i < 10; i++) {
            Node node = factory.newNode();
            node.getNodeData().setLabel("Node " + i);
            graph.addNode(node);
            System.out.println("Node " + i + " added. Id = " + node.getId());
        }

        graph.readLock();

        //Test
        assertEquals("root size", 11, treeStructure.getTreeSize());
        assertEquals("graph size", 10, graph.getNodeCount());

        for (int i = 0; i < 10; i++) {
            AbstractNode n = treeStructure.getNodeAt(i);
            assertEquals("AbstractNode pre", i, n.getPre());
            assertEquals("AbstractNode id", i, n.getId());
            assertEquals("AbstractNode enabled", i > 0, n.isEnabled());
            assertEquals("AbstractNode avl node", i, n.avlNode.getIndex());
            if (n.avlNode.next() != null) {
                assertEquals("AbstractNode next", treeStructure.getNodeAt(i + 1).avlNode, n.avlNode.next());
            }
            if (n.avlNode.previous() != null) {
                assertEquals("AbstractNode previous", treeStructure.getNodeAt(i - 1).avlNode, n.avlNode.previous());
            }
        }

        int i = 1;
        for (Node node : graph.getNodes()) {
            assertEquals("node iterator", i, node.getId());
            i++;
        }

        graph.readUnlock();
    }

    @Test
    public void testRemoveNode() {
        DhnsGraphController controller = new DhnsGraphController();
        Dhns dhns = new Dhns(controller, null);
        HierarchicalDirectedGraphImpl graph = new HierarchicalDirectedGraphImpl(dhns, dhns.getGraphStructure().getMainView());
        TreeStructure treeStructure = dhns.getGraphStructure().getMainView().getStructure();
        GraphFactoryImpl factory = dhns.factory();

        Node first = null;
        Node middle = null;
        Node end = null;
        for (int i = 0; i < 10; i++) {
            Node node = factory.newNode();
            node.getNodeData().setLabel("Node " + i);
            graph.addNode(node);
            System.out.println("Node " + i + " added. Id = " + node.getId());

            if (i == 0) {
                first = node;
            } else if (i == 4) {
                middle = node;
            } else if (i == 9) {
                end = node;
            }
        }

        graph.removeNode(first);

        //Test1
        System.out.print("Test1 nodes: ");
        for (int i = 0; i < treeStructure.getTreeSize(); i++) {
            AbstractNode n = treeStructure.getNodeAt(i);
            System.out.print(n.getId() + " ");
            assertEquals("AbstractNode pre", i, n.getPre());
            assertEquals("AbstractNode avl node", i, n.avlNode.getIndex());
            if (n.avlNode.next() != null) {
                assertEquals("AbstractNode next", treeStructure.getNodeAt(i + 1).avlNode, n.avlNode.next());
            }
            if (n.avlNode.previous() != null) {
                assertEquals("AbstractNode previous", treeStructure.getNodeAt(i - 1).avlNode, n.avlNode.previous());
            }
        }
        System.out.println();
        //End Test1

        graph.removeNode(middle);

        //Test2
        System.out.print("Test2 nodes: ");
        for (int i = 0; i < treeStructure.getTreeSize(); i++) {
            AbstractNode n = treeStructure.getNodeAt(i);
            System.out.print(n.getId() + " ");
            assertEquals("AbstractNode pre", i, n.getPre());
            assertEquals("AbstractNode avl node", i, n.avlNode.getIndex());
            if (n.avlNode.next() != null) {
                assertEquals("AbstractNode next", treeStructure.getNodeAt(i + 1).avlNode, n.avlNode.next());
            }
            if (n.avlNode.previous() != null) {
                assertEquals("AbstractNode previous", treeStructure.getNodeAt(i - 1).avlNode, n.avlNode.previous());
            }
        }
        System.out.println();
        //End Test2


        graph.removeNode(end);

        //Test3
        System.out.print("Test3 nodes: ");
        for (int i = 0; i < treeStructure.getTreeSize(); i++) {
            AbstractNode n = treeStructure.getNodeAt(i);
            System.out.print(n.getId() + " ");
            assertEquals("AbstractNode pre", i, n.getPre());
            assertEquals("AbstractNode avl node", i, n.avlNode.getIndex());
            if (n.avlNode.next() != null) {
                assertEquals("AbstractNode next", treeStructure.getNodeAt(i + 1).avlNode, n.avlNode.next());
            }
            if (n.avlNode.previous() != null) {
                assertEquals("AbstractNode previous", treeStructure.getNodeAt(i - 1).avlNode, n.avlNode.previous());
            }
        }
        System.out.println();
        //End Test3

        assertFalse(graph.contains(first));
        assertFalse(graph.contains(middle));
        assertFalse(graph.contains(end));

        AbstractNode AbstractNode = (AbstractNode) first;
        assertNull(AbstractNode.avlNode);
        assertNull(AbstractNode.parent);

        //Test
        assertEquals("tree size", 8, treeStructure.getTreeSize());
    }

    @Test
    public void testContainsNode() {

        Node node = nodeMap.get("Node 1");
        boolean contains = graphGlobal.contains(node);

        //Test
        assertTrue("contains node", contains);
        assertFalse("not contains node", graphGlobal.contains(nodeMap.get("Fake Node 1")));
    }

    @Test
    public void testClearNodes() {

        TreeStructure treeStructure = dhnsGlobal.getGraphStructure().getMainView().getStructure();
        graphGlobal.clear();

        //Test
        assertEquals("clear nodes", 1, treeStructure.getTreeSize());
        assertEquals("clear nodes", 0, graphGlobal.getNodeCount());
        assertEquals("clear nodes", treeStructure.getRoot(), treeStructure.getNodeAt(0));

        assertFalse("not contains anymore", graphGlobal.contains(nodeMap.get("Node 1")));

        AbstractNode AbstractNode = (AbstractNode) nodeMap.get("Node 2");
        assertNull("clean clear", AbstractNode.avlNode);
        assertNull("clean clear", AbstractNode.parent);
    }

    @Test
    public void testAddEdge() {
        DhnsGraphController controller = new DhnsGraphController();
        Dhns dhns = new Dhns(controller, null);
        HierarchicalDirectedGraphImpl graph = new HierarchicalDirectedGraphImpl(dhns, dhns.getGraphStructure().getMainView());
        TreeStructure treeStructure = dhns.getGraphStructure().getMainView().getStructure();
        GraphFactoryImpl factory = dhns.factory();

        Node node1 = factory.newNode();
        Node node2 = factory.newNode();
        Node node3 = factory.newNode();
        graph.addNode(node1);
        graph.addNode(node2);
        graph.addNode(node3);

        //Test normal edge
        graph.addEdge(node1, node2);
        AbstractNode AbstractNode1 = (AbstractNode) node1;
        AbstractNode AbstractNode2 = (AbstractNode) node2;

        AbstractEdge edge = AbstractNode1.getEdgesOutTree().getItem(AbstractNode2.getNumber());
        assertNotNull("find OUT edge", edge);
        assertTrue("contains OUT edge", AbstractNode1.getEdgesOutTree().contains(edge));

        AbstractEdge edge2 = AbstractNode2.getEdgesInTree().getItem(AbstractNode1.getNumber());
        assertNotNull("find IN edge", edge);
        assertTrue("contains IN edge", AbstractNode2.getEdgesInTree().contains(edge2));

        assertSame("edges equal", edge, edge2);

        assertEquals("edges count", 1, graph.getEdgeCount());

        //Test factoryedge
        graph.addEdge(edge);
        assertEquals("edges count", 1, graph.getEdgeCount());

        //Test self loop
        graph.addEdge(node3, node3);

        AbstractNode AbstractNode3 = (AbstractNode) node3;

        AbstractEdge edge3 = AbstractNode3.getEdgesOutTree().getItem(AbstractNode3.getNumber());
        assertNotNull("find OUT edge", edge);
        assertTrue("contains OUT edge", AbstractNode3.getEdgesOutTree().contains(edge3));

        AbstractEdge edge4 = AbstractNode3.getEdgesInTree().getItem(AbstractNode3.getNumber());
        assertNotNull("find IN edge", edge);
        assertTrue("contains IN edge", AbstractNode3.getEdgesInTree().contains(edge3));

        assertSame("edges equal", edge3, edge4);

        assertTrue("is self loop", edge3.isSelfLoop());
    }

    @Test
    public void testRemoveEdge() {
        GraphFactoryImpl factory = dhnsGlobal.factory();
        AbstractNode node3 = (AbstractNode) nodeMap.get("Node 1");
        AbstractNode node4 = (AbstractNode) nodeMap.get("Node 2");
        AbstractEdge edge = factory.newEdge(node3, node4);

        graphGlobal.addEdge(edge);
        assertTrue(graphGlobal.contains(edge));

        graphGlobal.removeEdge(edge);
        AbstractEdge edge3 = node3.getEdgesOutTree().getItem(node4.getNumber());
        assertNull("OUT null", edge3);
        assertFalse("contains OUT edge", node3.getEdgesOutTree().contains(edge));

        AbstractEdge edge4 = node4.getEdgesInTree().getItem(node3.getNumber());
        assertNull("IN null", edge4);
        assertFalse("contains IN edge", node3.getEdgesInTree().contains(edge));

        assertFalse(graphGlobal.contains(edge));

        Edge edge7 = edgeMap.get("7-7");
        assertTrue(graphGlobal.contains(edge7));
        graphGlobal.removeEdge(edge7);
        assertFalse(graphGlobal.contains(edge7));
    }

    @Test
    public void testRemoveEdge2() {
        DhnsGraphController controller = new DhnsGraphController();
        Dhns dhns = new Dhns(controller, null);
        HierarchicalDirectedGraphImpl graph = new HierarchicalDirectedGraphImpl(dhns, dhns.getGraphStructure().getMainView());
        TreeStructure treeStructure = dhns.getGraphStructure().getMainView().getStructure();
        GraphFactoryImpl factory = dhns.factory();

        Node node1 = factory.newNode();
        Node node2 = factory.newNode();
        graph.addNode(node1);
        graph.addNode(node2);

        AbstractEdge edge1 = factory.newEdge(node1, node2, 3f, true);
        graph.addEdge(edge1);
        AbstractEdge edge2 = factory.newEdge(node2, node1, 1f, true);
        graph.addEdge(edge2);

        graph.removeEdge(edge2);

        assertEquals(edge1, graph.getEdges().toArray()[0]);
        assertFalse(graph.contains(edge2));

        graph.removeEdge(edge1);
        assertFalse(graph.contains(edge1));
        assertEquals(0, graph.getEdgeCount());
    }

    @Test
    public void testGetEdges() {

        //Test1
        Edge[] expected = new Edge[5];
        expected[0] = edgeMap.get("4-4");
        expected[1] = edgeMap.get("4-5");
        expected[2] = edgeMap.get("5-6");
        expected[3] = edgeMap.get("6-5");
        expected[4] = edgeMap.get("7-7");
        Edge[] actual = new Edge[5];

        int i = 0;
        System.out.print("testGetEdges: ");
        for (Edge e : graphGlobal.getEdges()) {
            Node s = e.getSource();
            Node t = e.getTarget();
            Edge ed = edgeMap.get((s.getId()-1) + "-" + (t.getId()-1));
            assertSame("edge iterator", e, ed);
            System.out.print("#" + s.getId() + "-" + t.getId() + " ");
            actual[i++] = e;
        }
        System.out.println();
        assertArrayEquals(expected, actual);
        assertEquals("edge count", i, graphGlobal.getEdgeCount());


        graphGlobal.removeNode(nodeMap.get("Node 5"));

        //Test2
        expected = new Edge[2];
        expected[0] = edgeMap.get("4-4");
        expected[1] = edgeMap.get("7-7");
        actual = new Edge[2];
        i = 0;
        System.out.print("testGetEdges: ");
        for (Edge e : graphGlobal.getEdges()) {
            Node s = e.getSource();
            Node t = e.getTarget();
            Edge ed = edgeMap.get((s.getId()-1) + "-" + (t.getId()-1));
            assertSame("edge iterator", e, ed);
            System.out.print("#" + s.getId() + "-" + t.getId() + " ");
            actual[i++] = e;
        }
        System.out.println();
        assertArrayEquals(expected, actual);
    }

    @Test
    public void testGetEdgesNode() {

        //Test1
        System.out.print("testGetEdgesNode: ");
        Edge[] expected = new Edge[3];
        expected[0] = edgeMap.get("5-6");
        expected[1] = edgeMap.get("4-5");
        expected[2] = edgeMap.get("6-5");
        Edge[] actual = new Edge[3];

        int i = 0;
        for (Edge e : graphGlobal.getEdges(nodeMap.get("Node 5"))) {
            Node s = e.getSource();
            Node t = e.getTarget();
            System.out.print("#" + s.getId() + "-" + t.getId() + " ");
            actual[i++] = e;
        }
        System.out.println();
        assertArrayEquals(expected, actual);

        //Test2
        System.out.print("testGetEdgesNode: ");
        expected = new Edge[1];
        expected[0] = edgeMap.get("7-7");
        actual = new Edge[1];
        i = 0;
        for (Edge e : graphGlobal.getEdges(nodeMap.get("Node 7"))) {
            Node s = e.getSource();
            Node t = e.getTarget();
            System.out.print("#" + s.getId() + "-" + t.getId() + " ");
            actual[i++] = e;
        }
        System.out.println();
        assertArrayEquals(expected, actual);
    }

    @Test
    public void testSucessors() {
        //Test
        System.out.print("testSucessors: ");
        Node[] expected = new Node[1];
        expected[0] = nodeMap.get("Node 6");
        Node[] actual = new Node[1];

        int i = 0;
        Node node5 = nodeMap.get("Node 5");
        for (Node n : graphGlobal.getSuccessors(node5)) {
            System.out.print(n.getId() + " ");
            actual[i++] = n;
            assertTrue(graphGlobal.isSuccessor(node5, n));
        }
        System.out.println();
        assertArrayEquals(expected, actual);

        //Test Self loop
        Node[] array = graphGlobal.getSuccessors(nodeMap.get("Node 7")).toArray();
        assertEquals("self loop array length 0", 0, array.length);
    }

    @Test
    public void testPredecessors() {
        //Test
        System.out.print("testPredecessors: ");
        Node[] expected = new Node[2];
        expected[0] = nodeMap.get("Node 4");
        expected[1] = nodeMap.get("Node 6");
        Node[] actual = new Node[2];

        int i = 0;
        Node node5 = nodeMap.get("Node 5");
        for (Node n : graphGlobal.getPredecessors(node5)) {
            System.out.print(n.getId() + " ");
            actual[i++] = n;
            assertTrue(graphGlobal.isPredecessor(node5, n));
        }
        System.out.println();
        assertArrayEquals(expected, actual);

        //Test Self loop
        Node[] array = graphGlobal.getSuccessors(nodeMap.get("Node 7")).toArray();
        assertEquals("self loop array length 0", 0, array.length);
    }

    @Test
    public void testNeighbors() {
        System.out.print("testNeighbors: ");
        Node[] expected = new Node[2];
        expected[0] = nodeMap.get("Node 6");
        expected[1] = nodeMap.get("Node 4");
        Node[] actual = new Node[2];

        int i = 0;
        Node node5 = nodeMap.get("Node 5");
        for (Node n : graphGlobal.getNeighbors(node5)) {
            System.out.print(n.getId() + " ");
            actual[i++] = n;
        }
        System.out.println();
        assertArrayEquals(expected, actual);

        //Test Self loop
        Node[] array = graphGlobal.getNeighbors(nodeMap.get("Node 7")).toArray();
        assertEquals("self loop array length 0", 0, array.length);
    }

    @Test
    public void testOpposite() {
        Node node4 = nodeMap.get("Node 4");
        Node node5 = nodeMap.get("Node 5");
        Edge edge1 = edgeMap.get("4-5");
        Edge edge2 = edgeMap.get("4-4");

        assertEquals(node5, graphGlobal.getOpposite(node4, edge1));
        assertEquals(node4, graphGlobal.getOpposite(node4, edge2));
    }

    @Test
    public void testDegree() {
        Node node5 = nodeMap.get("Node 5");
        Node node4 = nodeMap.get("Node 4");
        Node node7 = nodeMap.get("Node 7");

        assertEquals(3, graphGlobal.getDegree(node5));
        assertEquals(3, graphGlobal.getDegree(node4));
        assertEquals(2, graphGlobal.getDegree(node7));
    }

    @Test
    public void testAdjacent() {
        Node node4 = nodeMap.get("Node 4");
        Node node5 = nodeMap.get("Node 5");
        Node node6 = nodeMap.get("Node 6");
        Edge edge1 = edgeMap.get("4-5");
        Edge edge2 = edgeMap.get("5-6");

        assertTrue(graphGlobal.isAdjacent(node4, node5));
        assertFalse(graphGlobal.isAdjacent(node4, node6));
        assertTrue(graphGlobal.isAdjacent(edge1, edge2));
    }

    @Test
    public void testClearEdgesNode() {
        Node node4 = nodeMap.get("Node 4");
        Node node5 = nodeMap.get("Node 5");
        Edge edge1 = edgeMap.get("4-4");
        Edge edge2 = edgeMap.get("5-6");
        graphGlobal.clearEdges(node5);
        graphGlobal.clearEdges(node4);

        assertEquals(0, graphGlobal.getDegree(node5));
        assertEquals(0, graphGlobal.getDegree(node4));
        assertFalse(graphGlobal.contains(edge2));
        assertFalse(graphGlobal.contains(edge1));
        assertFalse(graphGlobal.isAdjacent(node4, node5));
        //assertFalse(graphGlobal.isAdjacent(edge1, edge2));        //Fail because no test verifying edge belongs to the structure
    }

    @Test
    public void testGetEdge() {
        Node node4 = nodeMap.get("Node 4");
        Node node5 = nodeMap.get("Node 5");

        assertNotNull(graphGlobal.getEdge(node4, node5));
        Edge selfLoop = graphGlobal.getEdge(node4, node4);
        assertTrue(graphGlobal.isSelfLoop(selfLoop));
    }

    @Test
    public void testGetInEdges() {

        //Test1
        System.out.print("testGetInEdges: ");
        Edge[] expected = new Edge[2];
        expected[0] = edgeMap.get("4-5");
        expected[1] = edgeMap.get("6-5");
        Edge[] actual = new Edge[2];

        int i = 0;
        Node node5 = nodeMap.get("Node 5");
        for (Edge e : graphGlobal.getInEdges(node5)) {
            Node s = e.getSource();
            Node t = e.getTarget();
            System.out.print("#" + s.getId() + "-" + t.getId() + " ");
            actual[i++] = e;
        }
        System.out.println();
        assertArrayEquals(expected, actual);

        //Test2
        assertEquals(graphGlobal.getInEdges(nodeMap.get("Node 4")).toArray()[0], edgeMap.get("4-4"));
    }

    @Test
    public void testGetOutEdges() {

        //Test1
        System.out.print("testGetOutEdges: ");
        Edge[] expected = new Edge[1];
        expected[0] = edgeMap.get("5-6");
        Edge[] actual = new Edge[1];

        int i = 0;
        Node node5 = nodeMap.get("Node 5");
        for (Edge e : graphGlobal.getOutEdges(node5)) {
            Node s = e.getSource();
            Node t = e.getTarget();
            System.out.print("#" + s.getId() + "-" + t.getId() + " ");
            actual[i++] = e;
        }
        System.out.println();
        assertArrayEquals(expected, actual);

        //Test2
        assertEquals(graphGlobal.getOutEdges(nodeMap.get("Node 4")).toArray()[0], edgeMap.get("4-4"));
    }

    @Test
    public void testEdgesCounting() {
        DhnsGraphController controller = new DhnsGraphController();
        Dhns dhns = new Dhns(controller, null);
        GraphViewImpl view = dhns.getGraphStructure().getMainView();
        HierarchicalDirectedGraphImpl graph = new HierarchicalDirectedGraphImpl(dhns, view);
        TreeStructure treeStructure = view.getStructure();
        GraphFactoryImpl factory = dhns.factory();

        AbstractNode node1 = factory.newNode();
        AbstractNode node2 = factory.newNode();
        AbstractNode node3 = factory.newNode();
        graph.addNode(node1);
        graph.addNode(node2);
        graph.addNode(node3);
        AbstractEdge edge1 = factory.newEdge(node1, node2);
        AbstractEdge edge2 = factory.newEdge(node2, node1);
        AbstractEdge edge3 = factory.newEdge(node3, node3);
        graph.addEdge(edge1);
        graph.addEdge(edge2);
        graph.addEdge(edge3);

        assertEquals(3, view.getEdgesCountTotal());
        assertEquals(1, view.getMutualEdgesTotal());
        assertEquals(3, view.getEdgesCountEnabled());
        assertEquals(1, view.getMutualEdgesEnabled());

        assertEquals(1, node1.getEnabledInDegree());
        assertEquals(1, node1.getEnabledOutDegree());
        assertEquals(1, node1.getEnabledMutualDegree());
        assertEquals(1, node2.getEnabledInDegree());
        assertEquals(1, node2.getEnabledOutDegree());
        assertEquals(1, node2.getEnabledMutualDegree());
        assertEquals(1, node3.getEnabledInDegree());
        assertEquals(1, node3.getEnabledOutDegree());
        assertEquals(0, node3.getEnabledMutualDegree());

        graph.clearEdges(node3);
        assertEquals(2, view.getEdgesCountTotal());
        assertEquals(1, view.getMutualEdgesTotal());
        assertEquals(0, node3.getEnabledInDegree());
        assertEquals(0, node3.getEnabledOutDegree());
        assertEquals(0, node3.getEnabledMutualDegree());

        graph.clearEdges(node1);
        assertEquals(0, view.getEdgesCountTotal());
        assertEquals(0, view.getMutualEdgesTotal());
        assertEquals(0, node1.getEnabledInDegree());
        assertEquals(0, node1.getEnabledOutDegree());
        assertEquals(0, node1.getEnabledMutualDegree());
        assertEquals(0, node2.getEnabledInDegree());
        assertEquals(0, node2.getEnabledOutDegree());
        assertEquals(0, node2.getEnabledMutualDegree());

        graph.addEdge(edge1);
        graph.addEdge(edge2);
        graph.addEdge(edge3);

        graph.removeEdge(edge3);
        assertEquals(2, view.getEdgesCountTotal());
        assertEquals(1, view.getMutualEdgesTotal());
        assertEquals(2, view.getEdgesCountEnabled());
        assertEquals(1, view.getMutualEdgesEnabled());
        assertEquals(0, node3.getEnabledInDegree());
        assertEquals(0, node3.getEnabledOutDegree());
        assertEquals(0, node3.getEnabledMutualDegree());

        graph.removeEdge(edge1);
        assertEquals(1, view.getEdgesCountTotal());
        assertEquals(0, view.getMutualEdgesTotal());
        assertEquals(1, view.getEdgesCountEnabled());
        assertEquals(0, view.getMutualEdgesEnabled());
        assertEquals(1, node1.getEnabledInDegree());
        assertEquals(0, node1.getEnabledOutDegree());
        assertEquals(0, node1.getEnabledMutualDegree());
        assertEquals(0, node2.getEnabledInDegree());
        assertEquals(1, node2.getEnabledOutDegree());
        assertEquals(0, node2.getEnabledMutualDegree());

        graph.addEdge(edge1);
        assertEquals(2, view.getEdgesCountTotal());
        assertEquals(1, view.getMutualEdgesTotal());
        assertEquals(2, view.getEdgesCountEnabled());
        assertEquals(1, view.getMutualEdgesEnabled());
        assertEquals(1, node1.getEnabledInDegree());
        assertEquals(1, node1.getEnabledOutDegree());
        assertEquals(1, node1.getEnabledMutualDegree());
        assertEquals(1, node2.getEnabledInDegree());
        assertEquals(1, node2.getEnabledOutDegree());
        assertEquals(1, node2.getEnabledMutualDegree());
    }
}