DhnsTestMultiLevel.java

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

This file is part of Gephi.

Gephi is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as
published by the Free Software Foundation, either version 3 of the
License, or (at your option) any later version.

Gephi is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU Affero General Public License for more details.

You should have received a copy of the GNU Affero General Public License
along with Gephi.  If not, see <http://www.gnu.org/licenses/>.
*/
package org.gephi.graph.dhns.core;

import java.util.HashMap;
import org.gephi.graph.api.Edge;
import org.gephi.graph.api.MetaEdge;
import org.gephi.graph.api.Node;
import org.gephi.graph.dhns.DhnsGraphController;
import org.gephi.graph.dhns.graph.HierarchicalDirectedGraphImpl;
import org.gephi.graph.dhns.node.AbstractNode;
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 DhnsTestMultiLevel {

    private Dhns dhns1;
    private HierarchicalDirectedGraphImpl graph1;
    private HashMap<String, AbstractNode> nodeMap;

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

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

    @Before
    public void setUp() {
        nodeMap = new HashMap<String, AbstractNode>();
        DhnsGraphController controller = new DhnsGraphController();
        dhns1 = new Dhns(controller, null);
        graph1 = new HierarchicalDirectedGraphImpl(dhns1, dhns1.getGraphStructure().getMainView());
        GraphFactoryImpl factory = dhns1.factory();

        AbstractNode nodeA = factory.newNode();
        AbstractNode nodeB = factory.newNode();
        AbstractNode nodeC = factory.newNode();
        AbstractNode nodeD = factory.newNode();
        AbstractNode nodeE = factory.newNode();
        graph1.addNode(nodeA);
        graph1.addNode(nodeB);
        graph1.addNode(nodeC, nodeA);
        graph1.addNode(nodeE, nodeB);
        graph1.addNode(nodeD, nodeA);
        graph1.addNode(nodeD, nodeB);
        nodeMap.put("nodeA", nodeA);
        nodeMap.put("nodeB", nodeB);
        nodeMap.put("nodeC", nodeC);
        nodeMap.put("nodeD", nodeD);
        nodeMap.put("nodeE", nodeE);
    }

    @After
    public void tearDown() {
        dhns1 = null;
        graph1 = null;
    }
/*
    @Test
    public void testDurableList() {

        TreeStructure treeStructure = new GraphStructure().getStructure();
        PreNode preNodeA = new PreNode(0, 0, 0, 0, null);
        PreNode preNodeB = new PreNode(1, 0, 0, 0, null);
        treeStructure.insertAsChild(preNodeA, treeStructure.getRoot());
        treeStructure.insertAsChild(preNodeB, treeStructure.getRoot());
        PreNode preNodeC = new PreNode(2, 0, 0, 0, preNodeA);
        PreNode preNodeD = new PreNode(3, 0, 0, 0, preNodeA);
        PreNode preNodeE = new PreNode(4, 0, 0, 0, preNodeB);
        treeStructure.insertAsChild(preNodeC, preNodeA);
        treeStructure.insertAsChild(preNodeD, preNodeA);
        treeStructure.insertAsChild(preNodeE, preNodeB);
        CloneNode cloneNodeD = new CloneNode(preNodeD);
        treeStructure.insertAsChild(cloneNodeD, preNodeB);

        //treeStructure.showTreeAsTable();
    }

    @Test
    public void testCloneAdd() {
        //Test that adding the node to a descendant fails
        Exception ex = null;
        try {
            graph1.addNode(nodeMap.get("nodeB"), nodeMap.get("nodeD"));        //Error, add descendant
        } catch (IllegalArgumentException e) {
            ex = e;
        }
        assertNotNull(ex);

        //Test descendant & ancestor
        assertTrue(graph1.isDescendant(nodeMap.get("nodeA"), nodeMap.get("nodeC")));
        assertTrue(graph1.isDescendant(nodeMap.get("nodeA"), nodeMap.get("nodeD")));
        assertTrue(graph1.isDescendant(nodeMap.get("nodeB"), nodeMap.get("nodeD")));
        assertTrue(graph1.isAncestor(nodeMap.get("nodeC"), nodeMap.get("nodeA")));
        assertTrue(graph1.isAncestor(nodeMap.get("nodeD"), nodeMap.get("nodeA")));
        assertTrue(graph1.isAncestor(nodeMap.get("nodeD"), nodeMap.get("nodeB")));
    }

    @Test
    public void testAddWithDescendants() {

        //Add A as child of E
        graph1.addNode(nodeMap.get("nodeA"), nodeMap.get("nodeE"));

        assertTrue(graph1.isDescendant(nodeMap.get("nodeE"), nodeMap.get("nodeC")));
        assertTrue(graph1.isDescendant(nodeMap.get("nodeE"), nodeMap.get("nodeA")));
        assertTrue(graph1.isDescendant(nodeMap.get("nodeE"), nodeMap.get("nodeD")));
        assertNotNull(nodeMap.get("nodeC").getOriginalNode().getClones());
        assertEquals(2, nodeMap.get("nodeD").getOriginalNode().countClones());
        assertEquals(9, graph1.getNodeCount());

        //Add the cloned node A to B
        AbstractNode cloneAafterE = nodeMap.get("nodeA").getOriginalNode().getClones();
        graph1.addNode(cloneAafterE, nodeMap.get("nodeB"));

        assertEquals(12, graph1.getNodeCount());
        assertEquals(3, nodeMap.get("nodeD").getOriginalNode().countClones());
        assertEquals(2, nodeMap.get("nodeA").getOriginalNode().countClones());

        // dhns1.getGraphStructure().getStructure().showTreeAsTable();
    }

    @Test
    public void testCloneRemove() {
        //Test remove a clone
        graph1.removeNode(nodeMap.get("nodeB"));
        assertFalse(graph1.contains(nodeMap.get("nodeD")));
        assertEquals(1, ((PreNode) nodeMap.get("nodeA")).size);
        assertEquals(2, ((PreNode) dhns1.getGraphStructure().getStructure().root).size);
        assertEquals(2, graph1.getNodeCount());

        setUp();

        //Test remove an original
        graph1.removeNode(nodeMap.get("nodeA"));
        assertFalse(graph1.contains(nodeMap.get("nodeD")));
        assertEquals(1, ((PreNode) nodeMap.get("nodeB")).size);
        assertEquals(2, ((PreNode) dhns1.getGraphStructure().getStructure().root).size);
        assertEquals(2, graph1.getNodeCount());

        //dhns1.getGraphStructure().getStructure().showTreeAsTable();

        //Test diamond
        DhnsGraphController controller = new DhnsGraphController();
        Dhns dhns = new Dhns(controller, null);
        HierarchicalDirectedGraphImpl graph = new HierarchicalDirectedGraphImpl(dhns, dhns.getGraphStructure());
        GraphFactoryImpl factory = dhns.factory();

        AbstractNode nodeA = factory.newNode();
        AbstractNode nodeB = factory.newNode();
        AbstractNode nodeC = factory.newNode();
        AbstractNode nodeD = factory.newNode();
        graph.addNode(nodeA);
        graph.addNode(nodeB, nodeA);
        graph.addNode(nodeC, nodeA);
        graph.addNode(nodeD, nodeB);
        graph.addNode(nodeD, nodeC);
        graph.addNode(nodeD, nodeA);

        graph.removeNode(nodeD);
        assertFalse(graph.contains(nodeD));
        assertEquals(2, ((PreNode) nodeA).size);

        //Test remove complex
        setUp();
        graph1.addNode(nodeMap.get("nodeA"), nodeMap.get("nodeE"));
        AbstractNode cloneAafterE = nodeMap.get("nodeA").getOriginalNode().getClones();
        graph1.addNode(cloneAafterE, nodeMap.get("nodeB"));
        graph1.removeNode(nodeMap.get("nodeA"));
        assertEquals(2, graph1.getNodeCount());
        assertTrue(graph1.contains(nodeMap.get("nodeB")));
        assertTrue(graph1.contains(nodeMap.get("nodeE")));

        //dhns.getGraphStructure().getStructure().showTreeAsTable();
    }

    @Test
    public void testEnabled() {
        graph1.expand(nodeMap.get("nodeB"));
        assertTrue(dhns1.getGraphStructure().getStructure().hasEnabledDescendant(nodeMap.get("nodeB")));

        //dhns1.getGraphStructure().getStructure().showTreeAsTable();
    }

    @Test
    public void testCloneLinkedList() {
        PreNode preNode = new PreNode(0, 0, 0, 0, null);
        CloneNode cn1 = new CloneNode(preNode);
        assertEquals(cn1, preNode.getClones());
        assertEquals(preNode, cn1.getPreNode());
        CloneNode cn2 = new CloneNode(preNode);
        assertEquals(cn2, preNode.getClones());
        assertEquals(cn1, cn2.getNext());
        assertNull(cn1.getNext());
        preNode.removeClone(cn2);
        assertEquals(cn1, preNode.getClones());
        CloneNode cn3 = new CloneNode(preNode);
        assertEquals(cn1, cn3.getNext());
        preNode.removeClone(cn1);
        assertNull(cn3.getNext());
        CloneNode cn4 = new CloneNode(preNode);
        CloneNode cn5 = new CloneNode(preNode);
        assertEquals(3, preNode.countClones());
        preNode.removeClone(cn4);
        assertEquals(cn3, cn5.getNext());
    }

    @Test
    public void testGetEnabledAncestors() {
        dhns1.getGraphStructure().getStructure().showTreeAsTable();
        AbstractNode[] enabled = dhns1.getGraphStructure().getStructure().getEnabledAncestorsOrSelf(nodeMap.get("nodeD"));
        assertArrayEquals(new AbstractNode[]{nodeMap.get("nodeA"), nodeMap.get("nodeB")}, enabled);
    }

    @Test
    public void testComputeMetaEdges() {

        GraphFactoryImpl factory = dhns1.factory();
        Node nodeF = factory.newNode();
        graph1.addNode(nodeF);
        graph1.addNode(nodeMap.get("nodeE"), nodeF);
        graph1.addEdge(nodeMap.get("nodeD"), nodeMap.get("nodeE"));

        Edge[] metaEdges = graph1.getMetaEdges().toArray();
        MetaEdge[] expectedArray = new MetaEdge[3];
        expectedArray[0] = graph1.getMetaEdge(nodeMap.get("nodeA"), nodeMap.get("nodeB"));
        expectedArray[1] = graph1.getMetaEdge(nodeMap.get("nodeA"), nodeF);
        expectedArray[2] = graph1.getMetaEdge(nodeMap.get("nodeB"), nodeF);
        assertArrayEquals(expectedArray, metaEdges);
    }*/
}